licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | code | 961 | """
Dynamical equations with faults for Multicopter.
# Variables
f ∈ R: total thrust
M ∈ R^3: moment
Λ: effectiveness matrix
"""
function Dynamics!(multicopter::Multicopter)
@Loggable function dynamics!(dx, x, p, t; u, Λ)
@assert all(diag(Λ) .>= 0.0) && all(diag(Λ) .<= 1.0)
@nested_log :FDI Λ = Matrix(Λ) # to assign off-diagonal terms for diffeq (if Λ <: Diagonal)
@nested_onlylog :input u_cmd = u
@nested_log :input u_saturated = FSimZoo.saturate(multicopter, u)
@nested_log :input u_faulted = Λ * u_saturated
@nested_onlylog :input u_actual = u_faulted
# @show u_faulted ./ u_saturated, t # for debugging
@nested_log :input ν = FSimZoo.input_to_force_moment(multicopter, u_faulted) # for manual input_to_force_moment transformation, extend this method
f, M = ν[1], ν[2:4]
@nested_log FSimZoo.__Dynamics!(multicopter)(dx, x, p, t; f=f, M=M) # :state, :input
end
end
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | code | 630 | using FaultTolerantControl
using Test
using LinearAlgebra
using Transducers
@testset "costs" begin
Q_p = Matrix(I, 3, 3)
Q_ω = Matrix(I, 3, 3)
F_p = Matrix(I, 3, 3)
F_ω = Matrix(I, 3, 3)
cf = PositionAngularVelocityCostFunctional(Q_p, Q_ω, F_p, F_ω)
# data
t0, tf = 0.0, 1.0
Δt = tf - t0
ts = t0:0.01:tf
e_p_nom = ones(3)
e_ω_nom = ones(3)
e_ps = ts |> Map(t -> e_p_nom) |> collect
e_ωs = ts |> Map(t -> e_ω_nom) |> collect
J = cost(cf, ts, e_ps, e_ωs)
@test J ≈ e_p_nom'*Q_p*e_p_nom*Δt + e_ω_nom'*Q_ω*e_ω_nom + e_ps[end]'*F_p*e_ps[end] + e_ωs[end]'*F_ω*e_ωs[end]
end
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | code | 1591 | using FaultTolerantControl
using ControlSystems: ss, gram
using LinearAlgebra
using Test
@testset "reconfigurability for linear system" begin
# [1, Section 3, example 1]
# # Refs
# [1] N. E. Wu, K. Zhou, and G. Salomon, “Control Reconfigurability of Linear Time-Invariant Systems,” p. 5, 2000.
A = [
-0.0226 -36.6 -18.9 -32.1;
0 -1.9 0.983 0;
0.0123 -11.7 -2.63 0;
0 0 1 0;
]
B = [
0 0;
-0.414 0;
-77.8 22.4;
0 0;
]
C = [
0 5.73 0 0;
0 0 0 5.73;
]
D = [
0 0;
0 0;
]
n = size(B)[1]
ssom_min = ssom(A, B, C, D)
@test ssom_min >= 10 && ssom_min < 12
end
@testset "reconfigurability" begin
# # Refs
# [2] https://github.com/gramian/emgr
A = -Matrix(I, 4, 4)
B = [0.0 1.0 0.0 1.0]'
C = [0.0 0.0 1.0 1.0]
D = [0]
f(x, u, p, t) = A*x + B*u .+ p
g(x, u, p, t) = C*x
# System dimension
n = 4
m = 1
l = 1
x0 = [0.0, 0.0, 0.0, 0.0]
u0 = [0.0]
empirical_Wc = empirical_gramian(f, g, m, n, l; opt=:c, dt=0.01, tf=5.0, pr=zeros(4, 1), xs=x0, us=u0)
empirical_Wo = empirical_gramian(f, g, m, n, l; opt=:o, dt=0.01, tf=5.0, pr=zeros(4, 1), xs=x0, us=u0)
minHSV = min_HSV(empirical_Wc, empirical_Wo)
# @show empirical_Wc empirical_Wo minHSV
sys = ss(A, B, C, D)
Wc = gram(sys, :c)
Wo = gram(sys, :o)
eps = 1e-2
@test isapprox(norm(empirical_Wc), norm(Wc), atol=eps)
@test isapprox(norm(empirical_Wo), norm(Wo), atol=eps)
end
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | code | 108 | using FaultTolerantControl
using Test
@testset "FaultTolerantControl.jl" begin
include("costs.jl")
end
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | code | 620 | using FaultTolerantControl
using Transducers
using Plots
function main()
N = 4
d = 2
θ = [[0, 0], [0.3, 0.1], [0.5, 0.2], [0.7, 0.3], [1, 1]]
θ_x = θ |> Map(_θ -> _θ[1]) |> collect
θ_y = θ |> Map(_θ -> _θ[2]) |> collect
t0 = 0.0
tf = 1.0
curve = Bezier(θ, t0, tf)
curve_params = t0:0.01:tf
points = curve_params |> Map(curve) |> collect
points_x = points |> Map(point -> point[1]) |> collect
points_y = points |> Map(point -> point[2]) |> collect
fig = plot(points_x, points_y; label="Bezier curve")
plot!(fig, θ_x, θ_y; st=:scatter, label="control points")
end
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 0.3.3 | bc9ed807d18f9a7ef1aaa44c19d1c753afe5ea76 | docs | 1506 | # FaultTolerantControl
[FaultTolerantControl.jl](https://github.com/JinraeKim/FaultTolerantControl.jl) is a package for fault tolerant control (FTC).
## Notes
- This package is based on [FlightSims.jl](https://github.com/JinraeKim/FlightSims.jl).
## Changes in [email protected]
It is rewritten to be compatible with [email protected], [email protected].
## FTC using various CA (control allocation) methods
See `./test/CA_backstepping.jl`.
Run this at `./`.
- Parallel trajectory generation is available. Benchmarks with
1) M1 Macbook Air: 7 threads, about 4s / 7 trajectories
2) Ryzen 5900X: 24 threads, about 5s / 24 trajectories.
Note that the benchmark results may be outdated.
## To-do
- [x] Make a trajectory generator; to save trajectory command
via JLD2 safely (without reconstruction).
- [ ] Complete the main script for the second-year report; see [the related project](https://github.com/JinraeKim/FaultTolerantControl.jl/projects/4).
- [ ] Calculate objective functional
### Notes
- Previously written examples are deprecated; see previous versions, e.g., [email protected].
### Funding
This research was supported by Unmanned Vehicles Core Technology Research and Development Program through the National Research Foundation of Korea (NRF) and Unmanned Vehicle Advanced Research Center (UVARC) funded by the Ministry of Science and ICT, the Republic of Korea (2020M3C1C1A01083162).
| FaultTolerantControl | https://github.com/JinraeKim/FaultTolerantControl.jl.git |
|
[
"MIT"
] | 1.0.2 | c876f4e2a81fa233a4db84253850e86c5c311da6 | code | 395 | using MistyClosures
using Documenter
DocMeta.setdocmeta!(MistyClosures, :DocTestSetup, :(using MistyClosures); recursive=true)
makedocs(;
modules=[MistyClosures],
authors="Will Tebbutt, Frames White, and Hong Ge",
sitename="MistyClosures.jl",
format=Documenter.HTML(;
edit_link="main",
assets=String[],
),
pages=[
"Home" => "index.md",
],
)
| MistyClosures | https://github.com/compintell/MistyClosures.jl.git |
|
[
"MIT"
] | 1.0.2 | c876f4e2a81fa233a4db84253850e86c5c311da6 | code | 1016 | module MistyClosures
using Core: OpaqueClosure
using Core.Compiler: IRCode
import Base: show
struct MistyClosure{Toc<:OpaqueClosure}
oc::Toc
ir::IRCode
end
MistyClosure(ir::IRCode; kwargs...) = MistyClosure(OpaqueClosure(ir; kwargs...), ir)
(mc::MistyClosure)(x::Vararg{Any, N}) where {N} = mc.oc(x...)
# You can't deepcopy an `IRCode` because it contains a module.
function Base.deepcopy_internal(x::T, dict::IdDict) where {T<:MistyClosure}
return T(Base.deepcopy_internal(x.oc, dict), x.ir)
end
# Don't print out the IRCode object, because this tends to pollute the REPL. Just make it
# clear that this is a MistyClosure, which contains an OpaqueClosure.
show(io::IO, mime::MIME"text/plain", mc::MistyClosure) = _show_misty_closure(io, mime, mc)
show(io::IO, mc::MistyClosure) = _show_misty_closure(io, MIME"text/plain"(), mc)
function _show_misty_closure(io::IO, mime::MIME"text/plain", mc::MistyClosure)
print(io, "MistyClosure ")
show(io, mime, mc.oc)
end
export MistyClosure
end
| MistyClosures | https://github.com/compintell/MistyClosures.jl.git |
|
[
"MIT"
] | 1.0.2 | c876f4e2a81fa233a4db84253850e86c5c311da6 | code | 665 | using MistyClosures, Test
using Core: OpaqueClosure
@testset "MistyClosures.jl" begin
ir = Base.code_ircode_by_type(Tuple{typeof(sin), Float64})[1][1]
# Recommended constructor.
mc = MistyClosure(ir; do_compile=true)
@test @inferred(mc(5.0)) == sin(5.0)
# Default constructor.
mc_default = MistyClosure(OpaqueClosure(ir; do_compile=true), ir)
@test @inferred(mc_default(5.0) == sin(5.0))
# deepcopy
@test deepcopy(mc) isa typeof(mc)
# printing -- we shouldn't see the IRCode, because it's often quite a lot.
io = IOBuffer()
show(io, mc)
@test String(take!(io)) == "MistyClosure (::Float64)::Float64->◌"
end
| MistyClosures | https://github.com/compintell/MistyClosures.jl.git |
|
[
"MIT"
] | 1.0.2 | c876f4e2a81fa233a4db84253850e86c5c311da6 | docs | 1548 | # MistyClosures
[](https://github.com/compintell/MistyClosures.jl/actions/workflows/CI.yml?query=branch%3Amain)
[](https://github.com/invenia/BlueStyle)
[](https://github.com/SciML/ColPrac)
Marginally less opaque closures.
Specifically, a `MistyClosure` is comprises an `OpaqueClosure` paired with the `IRCode` that defines it.
This is useful if you generate an `OpaqueClosure`, and want to be able to retrieve the `IRCode` later on.
## Recommended Use
```julia
# Get the `IRCode` associated to `sin(5.0)`.
ir = Base.code_ircode_by_type(Tuple{typeof(sin), Float64})[1][1]
# Produce a `MistyClosure` using it. All kwargs are passed to the `OpaqueClosure`
# constructor.
mc = MistyClosure(ir; do_compile=true)
# Call it.
mc(5.0) == sin(5.0)
```
## Alterative Use
Sometimes you'll already have an `OpaqueClosure` lying around, and not want to produce a new one from an `IRCode` (as this often takes a surprisingly large amount of time).
If ths is the case, you can simply use the default constructor for `MistyClosure`.
That is, write
```julia
mc = MistyClosure(existing_opaque_closure, ir)
```
Of course, it is _your_ responsibility so ensure that `ir` and `existing_opaque_closure` are in agreement.
| MistyClosures | https://github.com/compintell/MistyClosures.jl.git |
|
[
"MIT"
] | 1.0.2 | c876f4e2a81fa233a4db84253850e86c5c311da6 | docs | 203 | ```@meta
CurrentModule = MistyClosures
```
# MistyClosures
Documentation for [MistyClosures](https://github.com/compintell/MistyClosures.jl).
```@index
```
```@autodocs
Modules = [MistyClosures]
```
| MistyClosures | https://github.com/compintell/MistyClosures.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 2647 | using AWS
using Documenter
"Transform snake-case names, like `this_name`, to pascal-snake-case, like `This_Name`."
pascal_snake_case(s) = join(titlecase.(split(s, "_")), "_")
"""
_generate_high_level_services_docs() -> Vector{Pair{String,String}}
Generate a documentation page for each high-level AWS Service API, and
return a `Vector` of `"service name" => "docs/src/services/service_name.md"` pairs.
Documentation pages are created at `docs/src/services/{service_name}.md`, and
populated with all docstrings from a module created with `@service Service_Name`.
"""
function _generate_high_level_services_docs()
services_dir = joinpath(@__DIR__, "src", "services")
mkpath(services_dir)
services_pages = Pair{String,String}[]
for jl_file in readdir(joinpath(pkgdir(AWS), "src", "services"))
service = first(splitext(jl_file))
# Create a module, e.g. `@service S3`, so we can extract docstrings from it.
service_module = Symbol(pascal_snake_case(service))
@eval @service $service_module
# Avoid `_`s in sidebar/titles/contents as it causes italics in markdown contexts.
service_name = replace(string(service_module), "_" => " ")
@info "Generating documentation page for `@service $service_module`"
md_file = string(service, ".md")
open(joinpath(services_dir, md_file), "w") do md
write(
md,
"""
```@meta
CurrentModule = Main.$service_module
```
# $service_name
This page documents function available when using the `$service_module`
module, created with [`@service $service_module`](@ref AWS.@service).
### Index
```@index
Pages = ["$md_file"]
Modules = [$service_module]
```
### Documentation
```@autodocs
Modules = [$service_module]
```
""",
)
end
push!(services_pages, service_name => joinpath("services", md_file))
end
return services_pages
end
makedocs(;
modules=[AWS],
repo="https://github.com/JuliaCloud/AWS.jl/blob/{commit}{path}#{line}",
sitename="AWS.jl",
format=Documenter.HTML(;
prettyurls=false, canonical="https://juliacloud.github.io/AWS.jl"
),
pages=[
"Home" => "index.md",
"Backends" => "backends.md",
"AWS" => "aws.md",
"IMDS" => "imds.md",
"Services" => _generate_high_level_services_docs(),
],
strict=true,
checkdocs=:exports,
)
deploydocs(; repo="github.com/JuliaCloud/AWS.jl", push_preview=true)
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 14038 | module AWS
using Compat: Compat, @compat, @something
using Base64
using Dates
using Downloads: Downloads, Downloader, Curl
using HTTP
using MbedTLS
using Mocking
using OrderedCollections: LittleDict, OrderedDict
using Random
using SHA
using Sockets
using URIs
using UUIDs: UUIDs
using XMLDict
export @service
export _merge
export AbstractAWSConfig, AWSConfig, AWSExceptions, AWSServices, Request
export IMDS
export assume_role, generate_service_url, global_aws_config, set_user_agent
export sign!, sign_aws2!, sign_aws4!
export JSONService, RestJSONService, RestXMLService, QueryService, set_features
const DEFAULT_REGION = "us-east-1"
include(joinpath("utilities", "utilities.jl"))
include("AWSExceptions.jl")
include("AWSCredentials.jl")
include("AWSConfig.jl")
include("AWSMetadata.jl")
include("IMDS.jl")
include(joinpath("utilities", "request.jl"))
include(joinpath("utilities", "response.jl"))
include(joinpath("utilities", "sign.jl"))
include(joinpath("utilities", "downloads_backend.jl"))
include(joinpath("utilities", "role.jl"))
include("deprecated.jl")
using ..AWSExceptions
using ..AWSExceptions: AWSException
const user_agent = Ref("AWS.jl/1.0.0")
const aws_config = Ref{AbstractAWSConfig}()
"""
FeatureSet
Allows end users to opt-in to new breaking behaviors prior before a major/breaking package
release. Each field of this struct contains a default which specifies uses the original
non-breaking behavior.
# Features
- `use_response_type::Bool=false`: When enabled, service calls will return an `AWS.Response`
which provides streaming/raw/parsed access to the response. When disabled, the service
call response typically be parsed but will vary depending on the following parameters:
"return_headers", "return_stream", "return_raw", "response_dict_type".
"""
Base.@kwdef struct FeatureSet
use_response_type::Bool = false
end
"""
global_aws_config()
Retrieve the global AWS configuration.
If one is not set, create one with default configuration options.
# Keywords
- `kwargs...`: AWSConfig kwargs to be passed along if the global configuration is not already set
# Returns
- `AWSConfig`: The global AWS configuration
"""
function global_aws_config(; kwargs...)
if !isassigned(aws_config) || !isempty(kwargs)
aws_config[] = AWSConfig(; kwargs...)
end
return aws_config[]
end
"""
global_aws_config(config::AbstractAWSConfig)
Set the global AWSConfig.
# Arguments
- `config::AWSConfig`: The AWSConfig to set in the global state
# Returns
- `AWSConfig`: Global AWSConfig
"""
function global_aws_config(config::AbstractAWSConfig)
return aws_config[] = config
end
"""
set_user_agent(new_user_agent::String)
Set the global user agent when making HTTP requests.
# Arguments
- `new_user_agent::String`: User agent to set when making HTTP requests
# Return
- `String`: The global user agent
"""
set_user_agent(new_user_agent::String) = return user_agent[] = new_user_agent
"""
@service module_name feature=val...
Include a high-level service wrapper based off of the `module_name` parameter optionally
supplying a list of `features`.
When calling the macro you cannot match the predefined constant for the low-level API.
The low-level API constants are named in all lowercase, and spaces replaced with underscores.
Examples:
```julia
using AWS.AWSServices: secrets_manager
using AWS: @service
# This matches the constant and will error!
@service secrets_manager
> ERROR: cannot assign a value to variable AWSServices.secrets_manager from module Main
# This does NOT match the filename structure and will error!
@service secretsmanager
> ERROR: could not open file /.julia/dev/AWS.jl/src/services/secretsmanager.jl
# All of the examples below are valid!
@service Secrets_Manager
@service SECRETS_MANAGER
@service sECRETS_MANAGER
# Using a feature
@service Secrets_Manager use_response_type = true
```
# Arguments
- `module_name::Symbol`: Name of the module and service to include high-level API wrappers in your namespace
- `features=val...`: A list of features to enable/disable for this high-level API include.
See `FeatureSet` for a list of available features.
# Return
- `Expression`: Module which embeds the high-level service API wrapper functions in your namespace
"""
macro service(module_name::Symbol, features...)
service_name = joinpath(@__DIR__, "services", lowercase(string(module_name)) * ".jl")
map(_assignment_to_kw!, features)
module_block = quote
using AWS: FeatureSet
const SERVICE_FEATURE_SET = FeatureSet(; $(features...))
include($service_name)
end
return Expr(:toplevel, Expr(:module, true, esc(module_name), esc(module_block)))
end
abstract type Service end
struct RestXMLService <: Service
signing_name::String
endpoint_prefix::String
api_version::String
end
struct QueryService <: Service
signing_name::String
endpoint_prefix::String
api_version::String
end
struct JSONService <: Service
signing_name::String
endpoint_prefix::String
api_version::String
json_version::String
target::String
end
struct RestJSONService <: Service
signing_name::String
endpoint_prefix::String
api_version::String
service_specific_headers::LittleDict{String,String}
end
function RestJSONService(signing_name::String, endpoint_prefix::String, api_version::String)
return RestJSONService(
signing_name, endpoint_prefix, api_version, LittleDict{String,String}()
)
end
struct ServiceWrapper{S<:Service}
service::S
feature_set::FeatureSet
end
function set_features(service::Service; features...)
return ServiceWrapper(service, FeatureSet(; features...))
end
# Needs to be included after the definition of struct otherwise it cannot find them
include("AWSServices.jl")
function generate_service_url(aws::AbstractAWSConfig, service::String, resource::String)
SERVICE_HOST = "amazonaws.com"
reg = region(aws)
regionless_services = ("iam", "route53")
if service in regionless_services || (service == "sdb" && reg == DEFAULT_REGION)
reg = ""
end
return string(
"https://", service, ".", isempty(reg) ? "" : "$reg.", SERVICE_HOST, resource
)
end
"""
(service::RestXMLService)(
request_method::String, request_uri::String, args::AbstractDict{String, <:Any}=Dict{String, String}();
aws_config::AbstractAWSConfig=aws_config
)
Perform a RestXML request to AWS.
# Arguments
- `request_method::String`: RESTful request type, e.g.: `GET`, `HEAD`, `PUT`, etc.
- `request_uri::String`: AWS URI for the endpoint
- `args::AbstractDict{String, <:Any}`: Additional arguments to be included in the request
# Keywords
- `aws_config::AbstractAWSConfig`: AWSConfig containing credentials and other information for fulfilling the request, default value is the global configuration
- `feature_set::FeatureSet`: Specifies opt-in functionality for this specific API call.
# Returns
- `Tuple` or `Dict`: If `return_headers` is passed in through `args` a Tuple containing the headers and response will be returned, otherwise just a `Dict`
"""
function (service::RestXMLService)(
request_method::String,
request_uri::String,
args::AbstractDict{String,<:Any}=Dict{String,Any}();
aws_config::AbstractAWSConfig=global_aws_config(),
feature_set::FeatureSet=FeatureSet(),
)
feature_set.use_response_type && _delete_legacy_response_kw_args!(args)
return_headers = _pop!(args, "return_headers", nothing)
request = Request(;
_extract_common_kw_args(service, args)...,
use_response_type=feature_set.use_response_type,
request_method=request_method,
content=_pop!(args, "body", ""),
)
if request.service == "s3"
request_uri = _clean_s3_uri(request_uri)
end
request.resource = _generate_rest_resource(request_uri, args)
query_str = HTTP.escapeuri(args)
if !isempty(query_str)
if occursin('?', request.resource)
request.resource *= "&$query_str"
else
request.resource *= "?$query_str"
end
end
request.url = generate_service_url(
aws_config, service.endpoint_prefix, request.resource
)
return submit_request(aws_config, request; return_headers=return_headers)
end
"""
(service::QueryService)(
operation::String, args::AbstractDict{String, <:Any}=Dict{String, Any}();
aws_config::AbstractAWSConfig=aws_config
)
Perform a Query request to AWS.
# Arguments
- `operation::String`:
- `args::AbstractDict{String, <:Any}`: Additional arguments to be included in the request
# Keywords
- `aws_config::AbstractAWSConfig`: AWSConfig containing credentials and other information for fulfilling the request, default value is the global configuration
- `feature_set::FeatureSet`: Specifies opt-in functionality for this specific API call.
# Returns
- `Tuple` or `Dict`: If `return_headers` is passed in through `args` a Tuple containing the headers and response will be returned, otherwise just a `Dict`
"""
function (service::QueryService)(
operation::String,
args::AbstractDict{String,<:Any}=Dict{String,Any}();
aws_config::AbstractAWSConfig=global_aws_config(),
feature_set::FeatureSet=FeatureSet(),
)
feature_set.use_response_type && _delete_legacy_response_kw_args!(args)
POST_RESOURCE = "/"
return_headers = _pop!(args, "return_headers", nothing)
request = Request(;
_extract_common_kw_args(service, args)...,
use_response_type=feature_set.use_response_type,
resource=POST_RESOURCE,
request_method="POST",
url=generate_service_url(aws_config, service.endpoint_prefix, POST_RESOURCE),
)
request.headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
args["Action"] = operation
args["Version"] = service.api_version
request.content = HTTP.escapeuri(_flatten_query(service.signing_name, args))
return submit_request(aws_config, request; return_headers=return_headers)
end
"""
(service::JSONService)(
operation::String, args::AbstractDict{String, <:Any}=Dict{String, Any}();
aws_config::AbstractAWSConfig=aws_config
)
Perform a JSON request to AWS.
# Arguments
- `operation::String`: Name of the operation to perform
- `args::AbstractDict{String, <:Any}`: Additional arguments to be included in the request
# Keywords
- `aws_config::AbstractAWSConfig`: AWSConfig containing credentials and other information for fulfilling the request, default value is the global configuration
- `feature_set::FeatureSet`: Specifies opt-in functionality for this specific API call.
# Returns
- `Tuple` or `Dict`: If `return_headers` is passed in through `args` a Tuple containing the headers and response will be returned, otherwise just a `Dict`
"""
function (service::JSONService)(
operation::String,
args::AbstractDict{String,<:Any}=Dict{String,Any}();
aws_config::AbstractAWSConfig=global_aws_config(),
feature_set::FeatureSet=FeatureSet(),
)
feature_set.use_response_type && _delete_legacy_response_kw_args!(args)
POST_RESOURCE = "/"
return_headers = _pop!(args, "return_headers", nothing)
request = Request(;
_extract_common_kw_args(service, args)...,
use_response_type=feature_set.use_response_type,
resource=POST_RESOURCE,
request_method="POST",
content=json(args),
url=generate_service_url(aws_config, service.endpoint_prefix, POST_RESOURCE),
)
request.headers["Content-Type"] = "application/x-amz-json-$(service.json_version)"
request.headers["X-Amz-Target"] = "$(service.target).$(operation)"
return submit_request(aws_config, request; return_headers=return_headers)
end
"""
(service::RestJSONService)(
request_method::String, request_uri::String, args::AbstractDict{String, <:Any}=Dict{String, String}();
aws_config::AbstractAWSConfig=aws_config
)
Perform a RestJSON request to AWS.
# Arguments
- `request_method::String`: RESTful request type, e.g.: `GET`, `HEAD`, `PUT`, etc.
- `request_uri::String`: AWS URI for the endpoint
- `args::AbstractDict{String, <:Any}`: Additional arguments to be included in the request
# Keywords
- `aws_config::AbstractAWSConfig`: AWSConfig containing credentials and other information for fulfilling the request, default value is the global configuration
- `feature_set::FeatureSet`: Specifies opt-in functionality for this specific API call.
# Returns
- `Tuple` or `Dict`: If `return_headers` is passed in through `args` a Tuple containing the headers and response will be returned, otherwise just a `Dict`
"""
function (service::RestJSONService)(
request_method::String,
request_uri::String,
args::AbstractDict{String,<:Any}=Dict{String,String}();
aws_config::AbstractAWSConfig=global_aws_config(),
feature_set::FeatureSet=FeatureSet(),
)
feature_set.use_response_type && _delete_legacy_response_kw_args!(args)
return_headers = _pop!(args, "return_headers", nothing)
request = Request(;
_extract_common_kw_args(service, args)...,
use_response_type=feature_set.use_response_type,
request_method=request_method,
resource=_generate_rest_resource(request_uri, args),
)
request.url = generate_service_url(
aws_config, service.endpoint_prefix, request.resource
)
if !isempty(service.service_specific_headers)
merge!(request.headers, service.service_specific_headers)
end
request.headers["Content-Type"] = "application/json"
request.content = json(args)
return submit_request(aws_config, request; return_headers=return_headers)
end
function (service::ServiceWrapper)(args...; feature_set=nothing, kwargs...)
feature_set = something(feature_set, service.feature_set)
return service.service(args...; feature_set=feature_set, kwargs...)
end
function __init__()
DEFAULT_BACKEND[] = HTTPBackend()
return nothing
end
end # module AWS
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 2565 | abstract type AbstractAWSConfig end
# https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html
const AWS_MAX_RETRY_ATTEMPTS = 3
"""
max_attempts(::AbstractAWSConfig) -> Int
The number of AWS request retry attempts to make.
Each backend may perform an additional layer backend-specific retries.
`AbstractAWSConfig` subtypes should allow users to override the default.
The default is 3, per the recommendations at
https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html
"""
max_attempts(::AbstractAWSConfig) = AWS_MAX_RETRY_ATTEMPTS
mutable struct AWSConfig <: AbstractAWSConfig
credentials::Union{AWSCredentials,Nothing}
region::String
output::String
max_attempts::Int
end
# provide a default for the new field since people were using the default constructor
AWSConfig(creds, region, output) = AWSConfig(creds, region, output, AWS_MAX_RETRY_ATTEMPTS)
credentials(aws::AWSConfig) = aws.credentials
region(aws::AWSConfig) = aws.region
max_attempts(aws::AWSConfig) = aws.max_attempts
function AWSConfig(;
profile=nothing,
creds=AWSCredentials(; profile=profile),
region=nothing,
output="json",
max_attempts=AWS_MAX_RETRY_ATTEMPTS,
)
region = @something region aws_get_region(; profile=profile)
return AWSConfig(creds, region, output, max_attempts)
end
"""
aws_user_arn(aws::AWSConfig) -> String
Retrieve the `User ARN` from the `AWSConfig`, if not present query STS to update the
`user_arn`.
# Arguments
- `aws::AWSConfig`: AWSConfig used to retrieve the user arn
"""
function aws_user_arn(aws::AWSConfig)
creds = aws.credentials
if isempty(creds.user_arn)
_update_creds!(aws)
end
return creds.user_arn
end
"""
aws_account_number(aws::AWSConfig) -> String
Retrieve the `AWS account number` from the `AWSConfig`, if not present query STS to update
the `AWS account number`.
# Arguments
- `aws::AWSConfig`: AWSConfig used to retrieve the AWS account number
"""
function aws_account_number(aws::AWSConfig)
creds = aws.credentials
if isempty(creds.account_number)
_update_creds!(aws)
end
return creds.account_number
end
function _update_creds!(aws_config::AWSConfig)
response = AWSServices.sts(
"GetCallerIdentity";
aws_config=aws_config,
feature_set=FeatureSet(; use_response_type=true),
)
dict = parse(response)["GetCallerIdentityResult"]
creds = aws_config.credentials
creds.user_arn = dict["Arn"]
creds.account_number = dict["Account"]
return creds
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 26598 | using Dates
using HTTP
using IniFile
using JSON
using Mocking
using ..AWSExceptions
export AWSCredentials,
aws_account_number,
aws_get_profile_settings,
aws_get_region,
aws_user_arn,
check_credentials,
credentials_from_webtoken,
dot_aws_config,
dot_aws_config_file,
dot_aws_credentials,
dot_aws_credentials_file,
ec2_instance_credentials,
ecs_instance_credentials,
env_var_credentials,
external_process_credentials,
localhost_is_ec2,
localhost_is_lambda,
localhost_maybe_ec2,
sso_credentials
function localhost_maybe_ec2()
return localhost_is_ec2() || isfile("/sys/devices/virtual/dmi/id/product_uuid")
end
localhost_is_lambda() = haskey(ENV, "LAMBDA_TASK_ROOT")
"""
AWSCredentials
When you interact with AWS, you specify your [AWS Security Credentials](http://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)
to verify who you are and whether you have permission to access the resources that you are requesting.
AWS uses the security credentials to authenticate and authorize your requests.
The fields `access_key_id` and `secret_key` hold the access keys used to authenticate API requests
(see [Creating, Modifying, and Viewing Access Keys](http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey)).
[Temporary Security Credentials](http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) require the extra session `token` field.
The `user_arn` and `account_number` fields are used to cache the result of the [`aws_user_arn`](@ref) and [`aws_account_number`](@ref) functions.
AWS.jl searches for credentials in multiple locations and stops once any credentials are found.
The credential preference order mostly [mirrors the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html#cli-chap-authentication-precedence)
and is as follows:
1. Credentials or a profile passed directly to the `AWSCredentials`
2. [Environment variables](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html)
3. [Web Identity](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html#cli-configure-role-oidc)
4. [AWS Single Sign-On (SSO)](http://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) provided via the AWS configuration file
5. [AWS credentials file](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) (e.g. "~/.aws/credentials")
6. [External process](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sourcing-external.html) set via `credential_process` in the AWS configuration file
7. [AWS configuration file](http://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html) set via `aws_access_key_id` in the AWS configuration file
8. [Amazon ECS container credentials](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
9. [Amazon EC2 instance metadata](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)
Once the credentials are found, the method by which they were accessed is stored in the `renew` field
and the `DateTime` at which they will expire is stored in the `expiry` field.
This allows the credentials to be refreshed as needed using [`check_credentials`](@ref).
If `renew` is set to `nothing`, no attempt will be made to refresh the credentials.
Any renewal function is expected to return `nothing` on failure or a populated `AWSCredentials` object on success.
The `renew` field of the returned `AWSCredentials` will be discarded and does not need to be set.
To specify the profile to use from `~/.aws/credentials`, do, for example, `AWSCredentials(profile="profile-name")`.
"""
mutable struct AWSCredentials
access_key_id::String
secret_key::String
token::String
user_arn::String
account_number::String
expiry::DateTime
renew::Union{Function,Nothing} # Function which can be used to refresh credentials
function AWSCredentials(
access_key_id,
secret_key,
token="",
user_arn="",
account_number="";
expiry=typemax(DateTime),
renew=nothing,
)
return new(
access_key_id, secret_key, token, user_arn, account_number, expiry, renew
)
end
end
# Needs to be included after struct AWSCredentials for compilation
include(joinpath("utilities", "credentials.jl"))
"""
AWSCredentials(; profile=nothing) -> Union{AWSCredentials, Nothing}
Create an AWSCredentials object, given a provided profile (if not provided "default" will be
used).
Checks credential locations in the order:
1. Environment Variables
2. ~/.aws/credentials
3. ~/.aws/config
4. EC2 or ECS metadata
# Keywords
- `profile::AbstractString`: Specific profile used to search for AWSCredentials
# Throws
- `error("Can't find AWS Credentials")`: AWSCredentials could not be found
"""
function AWSCredentials(; profile=nothing, throw_cred_error=true)
creds = nothing
credential_function = () -> nothing
explicit_profile = !isnothing(profile)
profile = @something profile _aws_get_profile()
# Define the credential preference order:
# https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html#cli-chap-authentication-precedence
#
# Note that the AWS CLI documentation states that EC2 instance credentials are preferred
# over ECS container credentials. However, in practice when `AWS_CONTAINER_*`
# environmental variables are set the ECS container credentials are prefered instead.
functions = [
() -> env_var_credentials(explicit_profile),
credentials_from_webtoken,
() -> sso_credentials(profile),
() -> dot_aws_credentials(profile),
() -> dot_aws_config(profile),
ecs_instance_credentials,
() -> ec2_instance_credentials(profile),
]
# Loop through our search locations until we get credentials back
for f in functions
credential_function = f
creds = credential_function()
creds === nothing || break
end
# If credentials are nothing, default to throwing an error, otherwise return nothing
if creds === nothing
if throw_cred_error
throw(NoCredentials("Can't find AWS credentials!"))
else
return nothing
end
end
creds.renew = credential_function
return creds
end
function Base.show(io::IO, c::AWSCredentials)
return print(
io,
c.user_arn,
isempty(c.user_arn) ? "" : " ",
"(",
c.account_number,
isempty(c.account_number) ? "" : ", ",
c.access_key_id,
isempty(c.secret_key) ? "" : ", $(c.secret_key[1:3])...",
isempty(c.token) ? "" : ", $(c.token[1:3])...",
", ",
c.expiry,
")",
)
end
function Base.copyto!(dest::AWSCredentials, src::AWSCredentials)
for f in fieldnames(typeof(dest))
setfield!(dest, f, getfield(src, f))
end
end
"""
check_credentials(
aws_creds::AWSCredentials, force_refresh::Bool=false
) -> AWSCredentials
Checks current AWSCredentials, refreshing them if they are soon to expire. If
`force_refresh` is `true` the credentials will be renewed immediately
# Arguments
- `aws_creds::AWSCredentials`: AWSCredentials to be checked / refreshed
# Keywords
- `force_refresh::Bool=false`: `true` to refresh the credentials
# Throws
- `error("Can't find AWS credentials!")`: If no credentials can be found
"""
function check_credentials(aws_creds::AWSCredentials; force_refresh::Bool=false)
if force_refresh || _will_expire(aws_creds)
credential_method = aws_creds.renew
if credential_method !== nothing
new_aws_creds = credential_method()
new_aws_creds === nothing && throw(NoCredentials("Can't find AWS credentials!"))
copyto!(aws_creds, new_aws_creds)
# Ensure credential_method is not overwritten by the new credentials
aws_creds.renew = credential_method
end
end
return aws_creds
end
check_credentials(aws_creds::Nothing) = aws_creds
"""
ec2_instance_credentials(profile::AbstractString) -> AWSCredentials
Parse the EC2 metadata to retrieve AWSCredentials.
"""
function ec2_instance_credentials(profile::AbstractString)
path = dot_aws_config_file()
ini = Inifile()
if isfile(path)
ini = read(ini, path)
end
# Any profile except default must specify the credential_source as Ec2InstanceMetadata.
if profile != "default"
source = _get_ini_value(ini, profile, "credential_source")
source == "Ec2InstanceMetadata" || return nothing
end
info = IMDS.get("/latest/meta-data/iam/info")
info === nothing && return nothing
info = JSON.parse(info)
# Get credentials for the role associated to the instance via instance profile.
name = IMDS.get("/latest/meta-data/iam/security-credentials/")
creds = IMDS.get("/latest/meta-data/iam/security-credentials/$name")
parsed = JSON.parse(creds)
instance_profile_creds = AWSCredentials(
parsed["AccessKeyId"],
parsed["SecretAccessKey"],
parsed["Token"],
info["InstanceProfileArn"];
expiry=DateTime(rstrip(parsed["Expiration"], 'Z')),
renew=() -> ec2_instance_credentials(profile),
)
# Look for a role to assume and return instance profile credentials if there is none.
role_arn = _get_ini_value(ini, profile, "role_arn")
role_arn === nothing && return instance_profile_creds
# Assume the role.
role_session = get(ENV, "AWS_ROLE_SESSION_NAME") do
_role_session_name(
"AWS.jl-role-",
basename(role_arn),
"-" * Dates.format(@mock(now(UTC)), dateformat"yyyymmdd\THHMMSS\Z"),
)
end
params = Dict{String,Any}("RoleArn" => role_arn, "RoleSessionName" => role_session)
duration = _get_ini_value(ini, profile, "duration_seconds")
if duration !== nothing
params["DurationSeconds"] = parse(Int, duration)
end
response = @mock AWSServices.sts(
"AssumeRole",
params;
aws_config=AWSConfig(; creds=instance_profile_creds),
feature_set=FeatureSet(; use_response_type=true),
)
dict = parse(response)
role_creds = dict["AssumeRoleResult"]["Credentials"]
role_user = dict["AssumeRoleResult"]["AssumedRoleUser"]
return AWSCredentials(
role_creds["AccessKeyId"],
role_creds["SecretAccessKey"],
role_creds["SessionToken"],
role_user["Arn"];
expiry=DateTime(rstrip(role_creds["Expiration"], 'Z')),
renew=() -> ec2_instance_credentials(profile),
)
end
"""
ecs_instance_credentials() -> Union{AWSCredentials, Nothing}
Retrieve credentials from the ECS credential endpoint. If the ECS credential endpoint is
unavailable then `nothing` will be returned.
More information can be found at:
- https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
- https://docs.aws.amazon.com/sdkref/latest/guide/feature-container-credentials.html
# Returns
- `AWSCredentials`: AWSCredentials from `ECS` credentials URI, `nothing` if the Env Var is
not set (not running on an ECS container instance)
# Throws
- `StatusError`: If the response status is >= 300
- `ParsingError`: Invalid HTTP request target
"""
function ecs_instance_credentials()
# The Amazon ECS agent will automatically populate the environmental variable
# `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` when running inside of an ECS task. We're
# interpreting this to mean than ECS credential provider should only be used if any of
# the `AWS_CONTAINER_CREDENTIALS_*_URI` variables are set.
# – https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
#
# > Note: This setting (`AWS_CONTAINER_CREDENTIALS_FULL_URI`) is an alternative to
# > `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` and will only be used if
# > `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` is not set.
# – https://docs.aws.amazon.com/sdkref/latest/guide/feature-container-credentials.html
if haskey(ENV, "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI")
endpoint = "http://169.254.170.2" * ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"]
elseif haskey(ENV, "AWS_CONTAINER_CREDENTIALS_FULL_URI")
endpoint = ENV["AWS_CONTAINER_CREDENTIALS_FULL_URI"]
else
return nothing
end
headers = Pair{String,String}[]
if haskey(ENV, "AWS_CONTAINER_AUTHORIZATION_TOKEN")
push!(headers, "Authorization" => ENV["AWS_CONTAINER_AUTHORIZATION_TOKEN"])
end
response = try
@mock HTTP.request("GET", endpoint, headers; retry=false, connect_timeout=5)
catch e
e isa HTTP.Exceptions.ConnectError && return nothing
rethrow()
end
new_creds = String(response.body)
new_creds = JSON.parse(new_creds)
expiry = DateTime(rstrip(new_creds["Expiration"], 'Z'))
return AWSCredentials(
new_creds["AccessKeyId"],
new_creds["SecretAccessKey"],
new_creds["Token"],
# The RoleArn field may not be present for Amazon SageMaker jobs
get(new_creds, "RoleArn", "");
expiry=expiry,
renew=ecs_instance_credentials,
)
end
"""
env_var_credentials(explicit_profile::Bool=false) -> Union{AWSCredentials, Nothing}
Use AWS environmental variables (e.g. AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, etc.)
to create AWSCredentials.
"""
function env_var_credentials(explicit_profile::Bool=false)
# Skip using environmental variables when a profile has been explicitly set
explicit_profile && return nothing
if haskey(ENV, "AWS_ACCESS_KEY_ID") && haskey(ENV, "AWS_SECRET_ACCESS_KEY")
return AWSCredentials(
ENV["AWS_ACCESS_KEY_ID"],
ENV["AWS_SECRET_ACCESS_KEY"],
get(ENV, "AWS_SESSION_TOKEN", ""),
get(ENV, "AWS_USER_ARN", "");
renew=env_var_credentials,
)
end
return nothing
end
"""
dot_aws_credentials(profile=nothing) -> Union{AWSCredentials, Nothing}
Retrieve `AWSCredentials` from the AWS CLI credentials file. The credential file defaults to
"~/.aws/credentials" but can be specified using the env variable
`AWS_SHARED_CREDENTIALS_FILE`.
# Arguments
- `profile`: Specific profile used to get AWSCredentials, default is `nothing`
"""
function dot_aws_credentials(profile=nothing)
credential_file = @mock dot_aws_credentials_file()
if isfile(credential_file)
ini = read(Inifile(), credential_file)
p = @something profile _aws_get_profile()
access_key, secret_key, token = _aws_get_credential_details(p, ini)
if access_key !== nothing
return AWSCredentials(access_key, secret_key, token)
end
end
return nothing
end
function dot_aws_credentials_file()
get(ENV, "AWS_SHARED_CREDENTIALS_FILE") do
joinpath(homedir(), ".aws", "credentials")
end
end
"""
sso_credentials(profile=nothing) -> Union{AWSCredentials, Nothing}
Retrieve credentials via AWS single sign-on (SSO) settings defined in the `profile` within
the AWS configuration file. If no SSO settings are found for the `profile` `nothing` is
returned.
# Arguments
- `profile`: Specific profile used to get `AWSCredentials`, default is `nothing`
"""
function sso_credentials(profile=nothing)
config_file = @mock dot_aws_config_file()
if isfile(config_file)
ini = read(Inifile(), config_file)
p = @something profile _aws_get_profile()
# get all the fields for that profile
settings = _aws_profile_config(ini, p)
isempty(settings) && return nothing
# AWS IAM Identity Center authentication is not yet supported in AWS.jl
sso_session = get(settings, "sso_session", nothing)
if !isnothing(sso_session)
error(
"IAM Identity Center authentication is not yet supported by AWS.jl. " *
"See https://github.com/JuliaCloud/AWS.jl/issues/628",
)
end
# Legacy SSO configuration
# https://docs.aws.amazon.com/cli/latest/userguide/sso-configure-profile-legacy.html#sso-configure-profile-manual
sso_start_url = get(settings, "sso_start_url", nothing)
if !isnothing(sso_start_url)
access_key, secret_key, token, expiry = _aws_get_sso_credential_details(p, ini)
return AWSCredentials(access_key, secret_key, token; expiry=expiry)
end
end
return nothing
end
"""
dot_aws_config(profile=nothing) -> Union{AWSCredentials, Nothing}
Retrieve `AWSCredentials` from the AWS CLI configuration file. The configuration file
defaults to "~/.aws/config" but can be specified using the env variable `AWS_CONFIG_FILE`.
When no credentials are found for the given `profile` then the associated `source_profile`
will be used to recursively look up credentials of source profiles. If still no credentials
can be found then `nothing` will be returned.
# Arguments
- `profile`: Specific profile used to get AWSCredentials, default is `nothing`
"""
function dot_aws_config(profile=nothing)
config_file = @mock dot_aws_config_file()
if isfile(config_file)
ini = read(Inifile(), config_file)
p = @something profile _aws_get_profile()
# get all the fields for that profile
settings = _aws_profile_config(ini, p)
isempty(settings) && return nothing
credential_process = get(settings, "credential_process", nothing)
access_key = get(settings, "aws_access_key_id", nothing)
sso_start_url = get(settings, "sso_start_url", nothing)
if !isnothing(credential_process)
cmd = Cmd(Base.shell_split(credential_process))
return external_process_credentials(cmd)
elseif !isnothing(access_key)
access_key, secret_key, token = _aws_get_credential_details(p, ini)
return AWSCredentials(access_key, secret_key, token)
elseif !isnothing(sso_start_url)
# Deprecation should only appear if `dot_aws_config` is called directly
Base.depwarn(
"SSO support in `dot_aws_config` is deprecated, use `sso_credentials` instead.",
:dot_aws_config,
)
access_key, secret_key, token, expiry = _aws_get_sso_credential_details(p, ini)
return AWSCredentials(access_key, secret_key, token; expiry=expiry)
else
return _aws_get_role(p, ini)
end
end
return nothing
end
function dot_aws_config_file()
get(ENV, "AWS_CONFIG_FILE") do
joinpath(homedir(), ".aws", "config")
end
end
"""
localhost_is_ec2() -> Bool
Determine if the machine executing this code is running on an EC2 instance.
"""
function localhost_is_ec2()
# Checking to see if you are running on an EC2 instance is a complicated problem due to
# a large amount of caveats. Below is a list of methods to implement to work through
# most of these problems:
#
# 1. Check the `hostname -d`; this will not work if using non-Amazon DNS
# 2. Check metadata with EC2 internal domain name `curl -s
# http://instance-data.ec2.internal`; this will not work with a VPC (legacy EC2 only)
# 3. Check `sudo dmidecode -s bios-version`; this requires `dmidecode` on the instance
# 4. Check `/sys/devices/virtual/dmi/id/bios_version`; this may not work depending on
# the instance, Amazon does not document this file however so it's quite unreliable
# 5. Check `http://169.254.169.254`; This is a link-local address for metadata,
# apparently other cloud providers make this metadata URL available now as well so it's
# not guaranteed that you're on an EC2 instance
# Or check a specific endpoint of the instance metadata such as:
# ims_local_hostname = String(HTTP.get("http://169.254.169.254/latest/meta-data/local-hostname").body)
# but with a fast timeout and cache the result.
# See https://docs.aws.amazon.com/en_us/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html
# 6. When checking the UUID, check for little-endian representation,
# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/identify_ec2_instances.html
# This is not guarenteed to work on Windows as RNG can make the UUID begin with EC2 on a
# non-EC2 instance
if @mock Sys.iswindows()
command = `wmic path win32_computersystemproduct get uuid`
result = @mock read(command, String)
instance_uuid = strip(split(result, "\n")[2])
return instance_uuid[1:3] == "EC2"
end
# Note: try catch required for open calls on files of mode 400 (-r--------)
# Note: This will not work on new m5 and c5 instances because they use a new hypervisor
# stack and the kernel does not create files in sysfs
hypervisor_uuid = "/sys/hypervisor/uuid"
if _can_read_file(hypervisor_uuid)
return true
end
# Note: Works if you are running as root
product_uuid = "/sys/devices/virtual/dmi/id/product_uuid"
if _can_read_file(product_uuid) && _begins_with_ec2(product_uuid)
return true
end
# Check additional values under /sys/devices/virtual/dmi/id for the key "EC2"
# These work for the new m5 and c5 (nitro hypervisor) when root isn't available
# filenames = ["bios_vendor", "board_vendor", "chassis_asset_tag", "chassis_version", "sys_vendor", "uevent", "modalias"]
# all return "Amazon EC2" except the last two
sys_vendor = "/sys/devices/virtual/dmi/id/sys_vendor"
if _can_read_file(sys_vendor) && _ends_with_ec2(sys_vendor)
return true
end
return false
end
"""
credentials_from_webtoken()
Assume role via web identity.
https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html#cli-configure-role-oidc
"""
function credentials_from_webtoken()
token_role_arn = "AWS_ROLE_ARN"
token_web_identity_file = "AWS_WEB_IDENTITY_TOKEN_FILE"
token_role_session = "AWS_ROLE_SESSION_NAME" # Optional session name
if !(haskey(ENV, token_role_arn) && haskey(ENV, token_web_identity_file))
return nothing
end
role_arn = ENV[token_role_arn]
web_identity = read(ENV["AWS_WEB_IDENTITY_TOKEN_FILE"], String)
role_session = get(ENV, token_role_session) do
_role_session_name(
"AWS.jl-role-",
basename(role_arn),
"-" * Dates.format(@mock(now(UTC)), dateformat"yyyymmdd\THHMMSS\Z"),
)
end
response = @mock AWSServices.sts(
"AssumeRoleWithWebIdentity",
Dict(
"RoleArn" => role_arn,
"RoleSessionName" => role_session, # Required by AssumeRoleWithWebIdentity
"WebIdentityToken" => web_identity,
);
aws_config=AWSConfig(; creds=nothing),
feature_set=FeatureSet(; use_response_type=true),
)
dict = parse(response)
role_creds = dict["AssumeRoleWithWebIdentityResult"]["Credentials"]
assumed_role_user = dict["AssumeRoleWithWebIdentityResult"]["AssumedRoleUser"]
return AWSCredentials(
role_creds["AccessKeyId"],
role_creds["SecretAccessKey"],
role_creds["SessionToken"],
assumed_role_user["Arn"];
expiry=DateTime(rstrip(role_creds["Expiration"], 'Z')),
renew=credentials_from_webtoken,
)
end
"""
external_process_credentials(cmd::Base.AbstractCmd) -> AWSCredentials
Sources AWS credentials from an external process as defined in the AWS CLI config file.
See https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sourcing-external.html
for details.
"""
function external_process_credentials(cmd::Base.AbstractCmd)
nt = open(cmd, "r") do io
_read_credential_process(io)
end
return AWSCredentials(
nt.access_key_id,
nt.secret_access_key,
@something(nt.session_token, "");
expiry=@something(nt.expiration, typemax(DateTime)),
renew=() -> external_process_credentials(cmd),
)
end
"""
aws_get_region(; profile=nothing, config=nothing, default="$DEFAULT_REGION")
Determine the current AWS region that should be used for AWS requests. The order of
precedence mirrors what is [used by the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-precedence):
1. Environmental variable: as specified by the `AWS_DEFAULT_REGION` environmental variable.
2. AWS configuration file: `region` as specified by the `profile` in the configuration
file, typically "~/.aws/config".
3. Instance metadata service on an Amazon EC2 instance that has an IAM role configured
4. Default region: use the specified `default`, typically "$DEFAULT_REGION".
# Keywords
- `profile`: Name of the AWS configuration profile, if any. Defaults to `nothing` which
falls back to using `AWS._aws_get_profile()`
- `config`: AWS configuration loaded as an `Inifile` or a path to a configuration file.
Defaults to `nothing` which falls back to using `dot_aws_config_file()`
- `default`: The region to return if no high-precedence was found. Can be useful to set
this to `nothing` if you want to know that no current AWS region was defined.
"""
function aws_get_region(; profile=nothing, config=nothing, default=DEFAULT_REGION)
@something(
get(ENV, "AWS_DEFAULT_REGION", nothing),
get(_aws_profile_config(config, profile), "region", nothing),
@mock(IMDS.region()),
Some(default),
)
end
@deprecate aws_get_region(profile::AbstractString, ini::Inifile) aws_get_region(;
profile=profile, config=ini
)
"""
aws_get_profile_settings(profile::AbstractString, ini::Inifile) -> Dict
Return a `Dict` containing all of the settings for the specified profile.
# Arguments
- `profile::AbstractString`: Profile to retrieve settings from
- `ini::Inifile`: Configuration file read the settings from
"""
function aws_get_profile_settings(profile::AbstractString, ini::Inifile)
section = get(sections(ini), "profile $profile", nothing)
# Internals of IniFile.jl always return strings for keys/values even though the returned
# Dict uses more generic type parameters
return section !== nothing ? Dict{String,String}(section) : nothing
end
@deprecate(
aws_get_role_details(profile::AbstractString, ini::Inifile),
get.(
Ref(aws_get_profile_settings(profile, ini)), ("source_profile", "role_arn"), nothing
),
)
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 4456 | module AWSExceptions
using HTTP
using JSON
using XMLDict
using XMLDict: XMLDictElement
export AWSException, IMDSUnavailable, ProtocolNotDefined, InvalidFileName, NoCredentials
struct IMDSUnavailable <: Exception end
function Base.show(io::IO, e::IMDSUnavailable)
msg = "$IMDSUnavailable: The Instance Metadata Service is unavailable on the host"
println(io, msg)
return nothing
end
struct ProtocolNotDefined <: Exception
message::String
end
Base.show(io::IO, e::ProtocolNotDefined) = println(io, e.message)
struct InvalidFileName <: Exception
message::String
end
Base.show(io::IO, e::InvalidFileName) = println(io, e.message)
struct NoCredentials <: Exception
message::String
end
Base.show(io::IO, e::NoCredentials) = println(io, e.message)
struct AWSException <: Exception
code::String
message::String
info::Union{XMLDictElement,Dict,String,Nothing}
cause::HTTP.StatusError
streamed_body::Union{String,Nothing}
end
function AWSException(code, message, info, cause)
return AWSException(code, message, info, cause, nothing)
end
function Base.show(io::IO, e::AWSException)
print(io, AWSException, ": ", e.code)
!isempty(e.message) && print(io, " -- ", e.message)
print(io, "\n\n", e.cause)
# When the response is streamed then `e.cause` will not show the response body
if e.streamed_body !== nothing
print(io, "\n\n")
if isempty(e.streamed_body)
printstyled(io, "(empty body)"; bold=true)
else
print(io, e.streamed_body)
end
end
println(io)
return nothing
end
AWSException(e::HTTP.StatusError) = AWSException(e, String(copy(e.response.body)))
AWSException(e::HTTP.StatusError, io::IOBuffer) = AWSException(e, String(take!(io)))
function AWSException(e::HTTP.StatusError, stream::IO)
seekstart(stream)
body = read(stream, String)
return AWSException(e, body)
end
function AWSException(e::HTTP.StatusError, stream::Base.BufferStream)
close(stream)
body = read(stream, String)
return AWSException(e, body)
end
function AWSException(e::HTTP.StatusError, body::AbstractString)
content_type = HTTP.header(e.response, "Content-Type")
code = string(e.status)
message = "AWSException"
info = Dict{String,Dict}()
try
if !isempty(body)
# Extract API error code from Lambda-style JSON error message...
if endswith(content_type, "json")
info = JSON.parse(body)
end
# Extract API error code from JSON error message...
if occursin(r"^application/x-amz-json-1\.[01]$", content_type)
info = JSON.parse(body)
if haskey(info, "__type")
code = rsplit(info["__type"], '#'; limit=2)[end]
end
end
# Extract API error code from XML error message...
if (
endswith(content_type, "/xml") ||
startswith(body, "<?xml") ||
startswith(body, r"<\w+ xmlns=")
)
info = parse_xml(body)
end
elseif parse(Int, HTTP.header(e.response, "Content-Length", "0")) > 0
# Should only occur streaming a response and error handling is improperly configured
@error "Internal Error: provided body is empty while the reported content-length " *
"is non-zero"
end
catch err
# Avoid throwing internal exceptions when parsing the error as this will result
# in the streamed content being hidden from the user.
@error sprint() do io
println(io, "Internal error: Failed to extract API error code:")
Base.showerror(io, err)
Base.show_backtrace(io, catch_backtrace())
println(io)
end
end
# Sometimes info is a string, in which case there is nothing else to do
if info isa AbstractDict
# There are times when Errors or Error are returned back
info = get(info, "Errors", info)
info = get(info, "Error", info)
code = get(info, "Code", code)
# There are also times when the response back is (M|m)essage
message = get(info, "Message", message)
message = get(info, "message", message)
end
streamed_body = !HTTP.isbytes(e.response.body) ? body : nothing
return AWSException(code, message, info, e, streamed_body)
end
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 1061 | module AWSMetadata
using Base64
using ..AWSExceptions
using GitHub
using HTTP
using JSON
using Mocking
using OrderedCollections: LittleDict, OrderedDict
const services_path = joinpath(@__DIR__, "AWSServices.jl")
include(joinpath("api_generation", "utilities.jl"))
include(joinpath("api_generation", "high_level.jl"))
include(joinpath("api_generation", "low_level.jl"))
"""
parse_aws_metadata()
Generate low and high level wrappers for each AWS Service based on their definitions in the
[aws-sdk-js GitHub Repository](https://github.com/aws/aws-sdk-js/tree/master/apis).
Low level wrappers are written into `src/AWSServices.jl`, while high level wrappers API
wrappers are written into their respective files in `src/services/{service}.jl`.
"""
function parse_aws_metadata()
auth = GitHub.authenticate(ENV["GITHUB_AUTH"])
repo_name = "aws/aws-sdk-js"
service_files = _get_service_files(repo_name, auth)
_generate_low_level_wrappers(service_files, auth)
_generate_high_level_wrapper(service_files, auth)
return nothing
end
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 38077 | # This file is auto-generated by AWSMetadata.jl
module AWSServices
using AWS
using OrderedCollections: LittleDict
const accessanalyzer = AWS.RestJSONService(
"access-analyzer", "access-analyzer", "2019-11-01"
)
const account = AWS.RestJSONService("account", "account", "2021-02-01")
const acm = AWS.JSONService("acm", "acm", "2015-12-08", "1.1", "CertificateManager")
const acm_pca = AWS.JSONService("acm-pca", "acm-pca", "2017-08-22", "1.1", "ACMPrivateCA")
const amp = AWS.RestJSONService("aps", "aps", "2020-08-01")
const amplify = AWS.RestJSONService("amplify", "amplify", "2017-07-25")
const amplifybackend = AWS.RestJSONService("amplifybackend", "amplifybackend", "2020-08-11")
const amplifyuibuilder = AWS.RestJSONService(
"amplifyuibuilder", "amplifyuibuilder", "2021-08-11"
)
const api_gateway = AWS.RestJSONService("apigateway", "apigateway", "2015-07-09")
const apigatewaymanagementapi = AWS.RestJSONService(
"execute-api", "execute-api", "2018-11-29"
)
const apigatewayv2 = AWS.RestJSONService("apigateway", "apigateway", "2018-11-29")
const app_mesh = AWS.RestJSONService("appmesh", "appmesh", "2019-01-25")
const appconfig = AWS.RestJSONService("appconfig", "appconfig", "2019-10-09")
const appconfigdata = AWS.RestJSONService("appconfig", "appconfigdata", "2021-11-11")
const appfabric = AWS.RestJSONService("appfabric", "appfabric", "2023-05-19")
const appflow = AWS.RestJSONService("appflow", "appflow", "2020-08-23")
const appintegrations = AWS.RestJSONService(
"app-integrations", "app-integrations", "2020-07-29"
)
const application_auto_scaling = AWS.JSONService(
"application-autoscaling",
"application-autoscaling",
"2016-02-06",
"1.1",
"AnyScaleFrontendService",
)
const application_discovery_service = AWS.JSONService(
"discovery", "discovery", "2015-11-01", "1.1", "AWSPoseidonService_V2015_11_01"
)
const application_insights = AWS.JSONService(
"applicationinsights",
"applicationinsights",
"2018-11-25",
"1.1",
"EC2WindowsBarleyService",
)
const application_signals = AWS.RestJSONService(
"application-signals", "application-signals", "2024-04-15"
)
const applicationcostprofiler = AWS.RestJSONService(
"application-cost-profiler", "application-cost-profiler", "2020-09-10"
)
const apprunner = AWS.JSONService(
"apprunner", "apprunner", "2020-05-15", "1.0", "AppRunner"
)
const appstream = AWS.JSONService(
"appstream", "appstream2", "2016-12-01", "1.1", "PhotonAdminProxyService"
)
const appsync = AWS.RestJSONService("appsync", "appsync", "2017-07-25")
const apptest = AWS.RestJSONService("apptest", "apptest", "2022-12-06")
const arc_zonal_shift = AWS.RestJSONService(
"arc-zonal-shift", "arc-zonal-shift", "2022-10-30"
)
const artifact = AWS.RestJSONService("artifact", "artifact", "2018-05-10")
const athena = AWS.JSONService("athena", "athena", "2017-05-18", "1.1", "AmazonAthena")
const auditmanager = AWS.RestJSONService("auditmanager", "auditmanager", "2017-07-25")
const auto_scaling = AWS.QueryService("autoscaling", "autoscaling", "2011-01-01")
const auto_scaling_plans = AWS.JSONService(
"autoscaling-plans",
"autoscaling-plans",
"2018-01-06",
"1.1",
"AnyScaleScalingPlannerFrontendService",
)
const b2bi = AWS.JSONService("b2bi", "b2bi", "2022-06-23", "1.0", "B2BI")
const backup = AWS.RestJSONService("backup", "backup", "2018-11-15")
const backup_gateway = AWS.JSONService(
"backup-gateway", "backup-gateway", "2021-01-01", "1.0", "BackupOnPremises_v20210101"
)
const batch = AWS.RestJSONService("batch", "batch", "2016-08-10")
const bcm_data_exports = AWS.JSONService(
"bcm-data-exports",
"bcm-data-exports",
"2023-11-26",
"1.1",
"AWSBillingAndCostManagementDataExports",
)
const bedrock = AWS.RestJSONService("bedrock", "bedrock", "2023-04-20")
const bedrock_agent = AWS.RestJSONService("bedrock", "bedrock-agent", "2023-06-05")
const bedrock_agent_runtime = AWS.RestJSONService(
"bedrock", "bedrock-agent-runtime", "2023-07-26"
)
const bedrock_runtime = AWS.RestJSONService("bedrock", "bedrock-runtime", "2023-09-30")
const billingconductor = AWS.RestJSONService(
"billingconductor", "billingconductor", "2021-07-30"
)
const braket = AWS.RestJSONService("braket", "braket", "2019-09-01")
const budgets = AWS.JSONService(
"budgets", "budgets", "2016-10-20", "1.1", "AWSBudgetServiceGateway"
)
const chatbot = AWS.RestJSONService("chatbot", "chatbot", "2017-10-11")
const chime = AWS.RestJSONService("chime", "chime", "2018-05-01")
const chime_sdk_identity = AWS.RestJSONService("chime", "identity-chime", "2021-04-20")
const chime_sdk_media_pipelines = AWS.RestJSONService(
"chime", "media-pipelines-chime", "2021-07-15"
)
const chime_sdk_meetings = AWS.RestJSONService("chime", "meetings-chime", "2021-07-15")
const chime_sdk_messaging = AWS.RestJSONService("chime", "messaging-chime", "2021-05-15")
const chime_sdk_voice = AWS.RestJSONService("chime", "voice-chime", "2022-08-03")
const cleanrooms = AWS.RestJSONService("cleanrooms", "cleanrooms", "2022-02-17")
const cleanroomsml = AWS.RestJSONService("cleanrooms-ml", "cleanrooms-ml", "2023-09-06")
const cloud9 = AWS.JSONService(
"cloud9", "cloud9", "2017-09-23", "1.1", "AWSCloud9WorkspaceManagementService"
)
const cloudcontrol = AWS.JSONService(
"cloudcontrolapi", "cloudcontrolapi", "2021-09-30", "1.0", "CloudApiService"
)
const clouddirectory = AWS.RestJSONService("clouddirectory", "clouddirectory", "2017-01-11")
const cloudformation = AWS.QueryService("cloudformation", "cloudformation", "2010-05-15")
const cloudfront = AWS.RestXMLService("cloudfront", "cloudfront", "2020-05-31")
const cloudhsm = AWS.JSONService(
"cloudhsm", "cloudhsm", "2014-05-30", "1.1", "CloudHsmFrontendService"
)
const cloudhsm_v2 = AWS.JSONService(
"cloudhsm", "cloudhsmv2", "2017-04-28", "1.1", "BaldrApiService"
)
const cloudsearch = AWS.QueryService("cloudsearch", "cloudsearch", "2013-01-01")
const cloudsearch_domain = AWS.RestJSONService(
"cloudsearch", "cloudsearchdomain", "2013-01-01"
)
const cloudtrail = AWS.JSONService(
"cloudtrail",
"cloudtrail",
"2013-11-01",
"1.1",
"com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101",
)
const cloudtrail_data = AWS.RestJSONService(
"cloudtrail-data", "cloudtrail-data", "2021-08-11"
)
const cloudwatch = AWS.QueryService("monitoring", "monitoring", "2010-08-01")
const cloudwatch_events = AWS.JSONService(
"events", "events", "2015-10-07", "1.1", "AWSEvents"
)
const cloudwatch_logs = AWS.JSONService(
"logs", "logs", "2014-03-28", "1.1", "Logs_20140328"
)
const codeartifact = AWS.RestJSONService("codeartifact", "codeartifact", "2018-09-22")
const codebuild = AWS.JSONService(
"codebuild", "codebuild", "2016-10-06", "1.1", "CodeBuild_20161006"
)
const codecatalyst = AWS.RestJSONService("codecatalyst", "codecatalyst", "2022-09-28")
const codecommit = AWS.JSONService(
"codecommit", "codecommit", "2015-04-13", "1.1", "CodeCommit_20150413"
)
const codeconnections = AWS.JSONService(
"codeconnections",
"codeconnections",
"2023-12-01",
"1.0",
"com.amazonaws.codeconnections.CodeConnections_20231201",
)
const codedeploy = AWS.JSONService(
"codedeploy", "codedeploy", "2014-10-06", "1.1", "CodeDeploy_20141006"
)
const codeguru_reviewer = AWS.RestJSONService(
"codeguru-reviewer", "codeguru-reviewer", "2019-09-19"
)
const codeguru_security = AWS.RestJSONService(
"codeguru-security", "codeguru-security", "2018-05-10"
)
const codeguruprofiler = AWS.RestJSONService(
"codeguru-profiler", "codeguru-profiler", "2019-07-18"
)
const codepipeline = AWS.JSONService(
"codepipeline", "codepipeline", "2015-07-09", "1.1", "CodePipeline_20150709"
)
const codestar = AWS.JSONService(
"codestar", "codestar", "2017-04-19", "1.1", "CodeStar_20170419"
)
const codestar_connections = AWS.JSONService(
"codestar-connections",
"codestar-connections",
"2019-12-01",
"1.0",
"com.amazonaws.codestar.connections.CodeStar_connections_20191201",
)
const codestar_notifications = AWS.RestJSONService(
"codestar-notifications", "codestar-notifications", "2019-10-15"
)
const cognito_identity = AWS.JSONService(
"cognito-identity", "cognito-identity", "2014-06-30", "1.1", "AWSCognitoIdentityService"
)
const cognito_identity_provider = AWS.JSONService(
"cognito-idp", "cognito-idp", "2016-04-18", "1.1", "AWSCognitoIdentityProviderService"
)
const cognito_sync = AWS.RestJSONService("cognito-sync", "cognito-sync", "2014-06-30")
const comprehend = AWS.JSONService(
"comprehend", "comprehend", "2017-11-27", "1.1", "Comprehend_20171127"
)
const comprehendmedical = AWS.JSONService(
"comprehendmedical",
"comprehendmedical",
"2018-10-30",
"1.1",
"ComprehendMedical_20181030",
)
const compute_optimizer = AWS.JSONService(
"compute-optimizer", "compute-optimizer", "2019-11-01", "1.0", "ComputeOptimizerService"
)
const config_service = AWS.JSONService(
"config", "config", "2014-11-12", "1.1", "StarlingDoveService"
)
const connect = AWS.RestJSONService("connect", "connect", "2017-08-08")
const connect_contact_lens = AWS.RestJSONService("connect", "contact-lens", "2020-08-21")
const connectcampaigns = AWS.RestJSONService(
"connect-campaigns", "connect-campaigns", "2021-01-30"
)
const connectcases = AWS.RestJSONService("cases", "cases", "2022-10-03")
const connectparticipant = AWS.RestJSONService(
"execute-api", "participant.connect", "2018-09-07"
)
const controlcatalog = AWS.RestJSONService("controlcatalog", "controlcatalog", "2018-05-10")
const controltower = AWS.RestJSONService("controltower", "controltower", "2018-05-10")
const cost_and_usage_report_service = AWS.JSONService(
"cur", "cur", "2017-01-06", "1.1", "AWSOrigamiServiceGatewayService"
)
const cost_explorer = AWS.JSONService(
"ce", "ce", "2017-10-25", "1.1", "AWSInsightsIndexService"
)
const cost_optimization_hub = AWS.JSONService(
"cost-optimization-hub",
"cost-optimization-hub",
"2022-07-26",
"1.0",
"CostOptimizationHubService",
)
const customer_profiles = AWS.RestJSONService("profile", "profile", "2020-08-15")
const data_pipeline = AWS.JSONService(
"datapipeline", "datapipeline", "2012-10-29", "1.1", "DataPipeline"
)
const database_migration_service = AWS.JSONService(
"dms", "dms", "2016-01-01", "1.1", "AmazonDMSv20160101"
)
const databrew = AWS.RestJSONService("databrew", "databrew", "2017-07-25")
const dataexchange = AWS.RestJSONService("dataexchange", "dataexchange", "2017-07-25")
const datasync = AWS.JSONService("datasync", "datasync", "2018-11-09", "1.1", "FmrsService")
const datazone = AWS.RestJSONService("datazone", "datazone", "2018-05-10")
const dax = AWS.JSONService("dax", "dax", "2017-04-19", "1.1", "AmazonDAXV3")
const deadline = AWS.RestJSONService("deadline", "deadline", "2023-10-12")
const detective = AWS.RestJSONService("detective", "api.detective", "2018-10-26")
const device_farm = AWS.JSONService(
"devicefarm", "devicefarm", "2015-06-23", "1.1", "DeviceFarm_20150623"
)
const devops_guru = AWS.RestJSONService("devops-guru", "devops-guru", "2020-12-01")
const direct_connect = AWS.JSONService(
"directconnect", "directconnect", "2012-10-25", "1.1", "OvertureService"
)
const directory_service = AWS.JSONService(
"ds", "ds", "2015-04-16", "1.1", "DirectoryService_20150416"
)
const dlm = AWS.RestJSONService("dlm", "dlm", "2018-01-12")
const docdb = AWS.QueryService("rds", "rds", "2014-10-31")
const docdb_elastic = AWS.RestJSONService("docdb-elastic", "docdb-elastic", "2022-11-28")
const drs = AWS.RestJSONService("drs", "drs", "2020-02-26")
const dynamodb = AWS.JSONService(
"dynamodb", "dynamodb", "2012-08-10", "1.0", "DynamoDB_20120810"
)
const dynamodb_streams = AWS.JSONService(
"dynamodb", "streams.dynamodb", "2012-08-10", "1.0", "DynamoDBStreams_20120810"
)
const ebs = AWS.RestJSONService("ebs", "ebs", "2019-11-02")
const ec2 = AWS.QueryService("ec2", "ec2", "2016-11-15")
const ec2_instance_connect = AWS.JSONService(
"ec2-instance-connect",
"ec2-instance-connect",
"2018-04-02",
"1.1",
"AWSEC2InstanceConnectService",
)
const ecr = AWS.JSONService(
"ecr", "api.ecr", "2015-09-21", "1.1", "AmazonEC2ContainerRegistry_V20150921"
)
const ecr_public = AWS.JSONService(
"ecr-public", "api.ecr-public", "2020-10-30", "1.1", "SpencerFrontendService"
)
const ecs = AWS.JSONService(
"ecs", "ecs", "2014-11-13", "1.1", "AmazonEC2ContainerServiceV20141113"
)
const efs = AWS.RestJSONService("elasticfilesystem", "elasticfilesystem", "2015-02-01")
const eks = AWS.RestJSONService("eks", "eks", "2017-11-01")
const eks_auth = AWS.RestJSONService("eks-auth", "eks-auth", "2023-11-26")
const elastic_beanstalk = AWS.QueryService(
"elasticbeanstalk", "elasticbeanstalk", "2010-12-01"
)
const elastic_inference = AWS.RestJSONService(
"elastic-inference", "api.elastic-inference", "2017-07-25"
)
const elastic_load_balancing = AWS.QueryService(
"elasticloadbalancing", "elasticloadbalancing", "2012-06-01"
)
const elastic_load_balancing_v2 = AWS.QueryService(
"elasticloadbalancing", "elasticloadbalancing", "2015-12-01"
)
const elastic_transcoder = AWS.RestJSONService(
"elastictranscoder", "elastictranscoder", "2012-09-25"
)
const elasticache = AWS.QueryService("elasticache", "elasticache", "2015-02-02")
const elasticsearch_service = AWS.RestJSONService("es", "es", "2015-01-01")
const emr = AWS.JSONService(
"elasticmapreduce", "elasticmapreduce", "2009-03-31", "1.1", "ElasticMapReduce"
)
const emr_containers = AWS.RestJSONService("emr-containers", "emr-containers", "2020-10-01")
const emr_serverless = AWS.RestJSONService("emr-serverless", "emr-serverless", "2021-07-13")
const entityresolution = AWS.RestJSONService(
"entityresolution", "entityresolution", "2018-05-10"
)
const eventbridge = AWS.JSONService("events", "events", "2015-10-07", "1.1", "AWSEvents")
const evidently = AWS.RestJSONService("evidently", "evidently", "2021-02-01")
const finspace = AWS.RestJSONService("finspace", "finspace", "2021-03-12")
const finspace_data = AWS.RestJSONService("finspace-api", "finspace-api", "2020-07-13")
const firehose = AWS.JSONService(
"firehose", "firehose", "2015-08-04", "1.1", "Firehose_20150804"
)
const fis = AWS.RestJSONService("fis", "fis", "2020-12-01")
const fms = AWS.JSONService("fms", "fms", "2018-01-01", "1.1", "AWSFMS_20180101")
const forecast = AWS.JSONService(
"forecast", "forecast", "2018-06-26", "1.1", "AmazonForecast"
)
const forecastquery = AWS.JSONService(
"forecast", "forecastquery", "2018-06-26", "1.1", "AmazonForecastRuntime"
)
const frauddetector = AWS.JSONService(
"frauddetector", "frauddetector", "2019-11-15", "1.1", "AWSHawksNestServiceFacade"
)
const freetier = AWS.JSONService(
"freetier", "freetier", "2023-09-07", "1.0", "AWSFreeTierService"
)
const fsx = AWS.JSONService(
"fsx", "fsx", "2018-03-01", "1.1", "AWSSimbaAPIService_v20180301"
)
const gamelift = AWS.JSONService("gamelift", "gamelift", "2015-10-01", "1.1", "GameLift")
const glacier = AWS.RestJSONService(
"glacier", "glacier", "2012-06-01", LittleDict("x-amz-glacier-version" => "2012-06-01")
)
const global_accelerator = AWS.JSONService(
"globalaccelerator",
"globalaccelerator",
"2018-08-08",
"1.1",
"GlobalAccelerator_V20180706",
)
const glue = AWS.JSONService("glue", "glue", "2017-03-31", "1.1", "AWSGlue")
const grafana = AWS.RestJSONService("grafana", "grafana", "2020-08-18")
const greengrass = AWS.RestJSONService("greengrass", "greengrass", "2017-06-07")
const greengrassv2 = AWS.RestJSONService("greengrass", "greengrass", "2020-11-30")
const groundstation = AWS.RestJSONService("groundstation", "groundstation", "2019-05-23")
const guardduty = AWS.RestJSONService("guardduty", "guardduty", "2017-11-28")
const health = AWS.JSONService(
"health", "health", "2016-08-04", "1.1", "AWSHealth_20160804"
)
const healthlake = AWS.JSONService(
"healthlake", "healthlake", "2017-07-01", "1.0", "HealthLake"
)
const iam = AWS.QueryService("iam", "iam", "2010-05-08")
const identitystore = AWS.JSONService(
"identitystore", "identitystore", "2020-06-15", "1.1", "AWSIdentityStore"
)
const imagebuilder = AWS.RestJSONService("imagebuilder", "imagebuilder", "2019-12-02")
const importexport = AWS.QueryService("importexport", "importexport", "2010-06-01")
const inspector = AWS.JSONService(
"inspector", "inspector", "2016-02-16", "1.1", "InspectorService"
)
const inspector2 = AWS.RestJSONService("inspector2", "inspector2", "2020-06-08")
const inspector_scan = AWS.RestJSONService("inspector-scan", "inspector-scan", "2023-08-08")
const internetmonitor = AWS.RestJSONService(
"internetmonitor", "internetmonitor", "2021-06-03"
)
const iot = AWS.RestJSONService("iot", "iot", "2015-05-28")
const iot_1click_devices_service = AWS.RestJSONService(
"iot1click", "devices.iot1click", "2018-05-14"
)
const iot_1click_projects = AWS.RestJSONService(
"iot1click", "projects.iot1click", "2018-05-14"
)
const iot_data_plane = AWS.RestJSONService("iotdata", "data-ats.iot", "2015-05-28")
const iot_events = AWS.RestJSONService("iotevents", "iotevents", "2018-07-27")
const iot_events_data = AWS.RestJSONService("ioteventsdata", "data.iotevents", "2018-10-23")
const iot_jobs_data_plane = AWS.RestJSONService(
"iot-jobs-data", "data.jobs.iot", "2017-09-29"
)
const iot_wireless = AWS.RestJSONService("iotwireless", "api.iotwireless", "2020-11-22")
const iotanalytics = AWS.RestJSONService("iotanalytics", "iotanalytics", "2017-11-27")
const iotdeviceadvisor = AWS.RestJSONService(
"iotdeviceadvisor", "api.iotdeviceadvisor", "2020-09-18"
)
const iotfleethub = AWS.RestJSONService("iotfleethub", "api.fleethub.iot", "2020-11-03")
const iotfleetwise = AWS.JSONService(
"iotfleetwise", "iotfleetwise", "2021-06-17", "1.0", "IoTAutobahnControlPlane"
)
const iotsecuretunneling = AWS.JSONService(
"IoTSecuredTunneling", "api.tunneling.iot", "2018-10-05", "1.1", "IoTSecuredTunneling"
)
const iotsitewise = AWS.RestJSONService("iotsitewise", "iotsitewise", "2019-12-02")
const iotthingsgraph = AWS.JSONService(
"iotthingsgraph", "iotthingsgraph", "2018-09-06", "1.1", "IotThingsGraphFrontEndService"
)
const iottwinmaker = AWS.RestJSONService("iottwinmaker", "iottwinmaker", "2021-11-29")
const ivs = AWS.RestJSONService("ivs", "ivs", "2020-07-14")
const ivs_realtime = AWS.RestJSONService("ivs", "ivsrealtime", "2020-07-14")
const ivschat = AWS.RestJSONService("ivschat", "ivschat", "2020-07-14")
const kafka = AWS.RestJSONService("kafka", "kafka", "2018-11-14")
const kafkaconnect = AWS.RestJSONService("kafkaconnect", "kafkaconnect", "2021-09-14")
const kendra = AWS.JSONService(
"kendra", "kendra", "2019-02-03", "1.1", "AWSKendraFrontendService"
)
const kendra_ranking = AWS.JSONService(
"kendra-ranking",
"kendra-ranking",
"2022-10-19",
"1.0",
"AWSKendraRerankingFrontendService",
)
const keyspaces = AWS.JSONService(
"cassandra", "cassandra", "2022-02-10", "1.0", "KeyspacesService"
)
const kinesis = AWS.JSONService(
"kinesis", "kinesis", "2013-12-02", "1.1", "Kinesis_20131202"
)
const kinesis_analytics = AWS.JSONService(
"kinesisanalytics", "kinesisanalytics", "2015-08-14", "1.1", "KinesisAnalytics_20150814"
)
const kinesis_analytics_v2 = AWS.JSONService(
"kinesisanalytics", "kinesisanalytics", "2018-05-23", "1.1", "KinesisAnalytics_20180523"
)
const kinesis_video = AWS.RestJSONService("kinesisvideo", "kinesisvideo", "2017-09-30")
const kinesis_video_archived_media = AWS.RestJSONService(
"kinesisvideo", "kinesisvideo", "2017-09-30"
)
const kinesis_video_media = AWS.RestJSONService(
"kinesisvideo", "kinesisvideo", "2017-09-30"
)
const kinesis_video_signaling = AWS.RestJSONService(
"kinesisvideo", "kinesisvideo", "2019-12-04"
)
const kinesis_video_webrtc_storage = AWS.RestJSONService(
"kinesisvideo", "kinesisvideo", "2018-05-10"
)
const kms = AWS.JSONService("kms", "kms", "2014-11-01", "1.1", "TrentService")
const lakeformation = AWS.RestJSONService("lakeformation", "lakeformation", "2017-03-31")
const lambda = AWS.RestJSONService("lambda", "lambda", "2015-03-31")
const launch_wizard = AWS.RestJSONService("launchwizard", "launchwizard", "2018-05-10")
const lex_model_building_service = AWS.RestJSONService("lex", "models.lex", "2017-04-19")
const lex_models_v2 = AWS.RestJSONService("lex", "models-v2-lex", "2020-08-07")
const lex_runtime_service = AWS.RestJSONService("lex", "runtime.lex", "2016-11-28")
const lex_runtime_v2 = AWS.RestJSONService("lex", "runtime-v2-lex", "2020-08-07")
const license_manager = AWS.JSONService(
"license-manager", "license-manager", "2018-08-01", "1.1", "AWSLicenseManager"
)
const license_manager_linux_subscriptions = AWS.RestJSONService(
"license-manager-linux-subscriptions",
"license-manager-linux-subscriptions",
"2018-05-10",
)
const license_manager_user_subscriptions = AWS.RestJSONService(
"license-manager-user-subscriptions", "license-manager-user-subscriptions", "2018-05-10"
)
const lightsail = AWS.JSONService(
"lightsail", "lightsail", "2016-11-28", "1.1", "Lightsail_20161128"
)
const location = AWS.RestJSONService("geo", "geo", "2020-11-19")
const lookoutequipment = AWS.JSONService(
"lookoutequipment",
"lookoutequipment",
"2020-12-15",
"1.0",
"AWSLookoutEquipmentFrontendService",
)
const lookoutmetrics = AWS.RestJSONService("lookoutmetrics", "lookoutmetrics", "2017-07-25")
const lookoutvision = AWS.RestJSONService("lookoutvision", "lookoutvision", "2020-11-20")
const m2 = AWS.RestJSONService("m2", "m2", "2021-04-28")
const machine_learning = AWS.JSONService(
"machinelearning", "machinelearning", "2014-12-12", "1.1", "AmazonML_20141212"
)
const macie2 = AWS.RestJSONService("macie2", "macie2", "2020-01-01")
const mailmanager = AWS.JSONService(
"ses", "mail-manager", "2023-10-17", "1.0", "MailManagerSvc"
)
const managedblockchain = AWS.RestJSONService(
"managedblockchain", "managedblockchain", "2018-09-24"
)
const managedblockchain_query = AWS.RestJSONService(
"managedblockchain-query", "managedblockchain-query", "2023-05-04"
)
const marketplace_agreement = AWS.JSONService(
"aws-marketplace",
"agreement-marketplace",
"2020-03-01",
"1.0",
"AWSMPCommerceService_v20200301",
)
const marketplace_catalog = AWS.RestJSONService(
"aws-marketplace", "catalog.marketplace", "2018-09-17"
)
const marketplace_commerce_analytics = AWS.JSONService(
"marketplacecommerceanalytics",
"marketplacecommerceanalytics",
"2015-07-01",
"1.1",
"MarketplaceCommerceAnalytics20150701",
)
const marketplace_deployment = AWS.RestJSONService(
"aws-marketplace", "deployment-marketplace", "2023-01-25"
)
const marketplace_entitlement_service = AWS.JSONService(
"aws-marketplace",
"entitlement.marketplace",
"2017-01-11",
"1.1",
"AWSMPEntitlementService",
)
const marketplace_metering = AWS.JSONService(
"aws-marketplace", "metering.marketplace", "2016-01-14", "1.1", "AWSMPMeteringService"
)
const mediaconnect = AWS.RestJSONService("mediaconnect", "mediaconnect", "2018-11-14")
const mediaconvert = AWS.RestJSONService("mediaconvert", "mediaconvert", "2017-08-29")
const medialive = AWS.RestJSONService("medialive", "medialive", "2017-10-14")
const mediapackage = AWS.RestJSONService("mediapackage", "mediapackage", "2017-10-12")
const mediapackage_vod = AWS.RestJSONService(
"mediapackage-vod", "mediapackage-vod", "2018-11-07"
)
const mediapackagev2 = AWS.RestJSONService("mediapackagev2", "mediapackagev2", "2022-12-25")
const mediastore = AWS.JSONService(
"mediastore", "mediastore", "2017-09-01", "1.1", "MediaStore_20170901"
)
const mediastore_data = AWS.RestJSONService("mediastore", "data.mediastore", "2017-09-01")
const mediatailor = AWS.RestJSONService("mediatailor", "api.mediatailor", "2018-04-23")
const medical_imaging = AWS.RestJSONService(
"medical-imaging", "medical-imaging", "2023-07-19"
)
const memorydb = AWS.JSONService(
"memorydb", "memory-db", "2021-01-01", "1.1", "AmazonMemoryDB"
)
const mgn = AWS.RestJSONService("mgn", "mgn", "2020-02-26")
const migration_hub = AWS.JSONService("mgh", "mgh", "2017-05-31", "1.1", "AWSMigrationHub")
const migration_hub_refactor_spaces = AWS.RestJSONService(
"refactor-spaces", "refactor-spaces", "2021-10-26"
)
const migrationhub_config = AWS.JSONService(
"mgh", "migrationhub-config", "2019-06-30", "1.1", "AWSMigrationHubMultiAccountService"
)
const migrationhuborchestrator = AWS.RestJSONService(
"migrationhub-orchestrator", "migrationhub-orchestrator", "2021-08-28"
)
const migrationhubstrategy = AWS.RestJSONService(
"migrationhub-strategy", "migrationhub-strategy", "2020-02-19"
)
const mobile = AWS.RestJSONService("AWSMobileHubService", "mobile", "2017-07-01")
const mobile_analytics = AWS.RestJSONService(
"mobileanalytics", "mobileanalytics", "2014-06-05"
)
const mq = AWS.RestJSONService("mq", "mq", "2017-11-27")
const mturk = AWS.JSONService(
"mturk-requester",
"mturk-requester",
"2017-01-17",
"1.1",
"MTurkRequesterServiceV20170117",
)
const mwaa = AWS.RestJSONService("airflow", "airflow", "2020-07-01")
const neptune = AWS.QueryService("rds", "rds", "2014-10-31")
const neptunedata = AWS.RestJSONService("neptune-db", "neptune-db", "2023-08-01")
const network_firewall = AWS.JSONService(
"network-firewall", "network-firewall", "2020-11-12", "1.0", "NetworkFirewall_20201112"
)
const networkmanager = AWS.RestJSONService("networkmanager", "networkmanager", "2019-07-05")
const networkmonitor = AWS.RestJSONService("networkmonitor", "networkmonitor", "2023-08-01")
const nimble = AWS.RestJSONService("nimble", "nimble", "2020-08-01")
const oam = AWS.RestJSONService("oam", "oam", "2022-06-10")
const omics = AWS.RestJSONService("omics", "omics", "2022-11-28")
const opensearch = AWS.RestJSONService("es", "es", "2021-01-01")
const opensearchserverless = AWS.JSONService(
"aoss", "aoss", "2021-11-01", "1.0", "OpenSearchServerless"
)
const opsworks = AWS.JSONService(
"opsworks", "opsworks", "2013-02-18", "1.1", "OpsWorks_20130218"
)
const opsworkscm = AWS.JSONService(
"opsworks-cm", "opsworks-cm", "2016-11-01", "1.1", "OpsWorksCM_V2016_11_01"
)
const organizations = AWS.JSONService(
"organizations", "organizations", "2016-11-28", "1.1", "AWSOrganizationsV20161128"
)
const osis = AWS.RestJSONService("osis", "osis", "2022-01-01")
const outposts = AWS.RestJSONService("outposts", "outposts", "2019-12-03")
const panorama = AWS.RestJSONService("panorama", "panorama", "2019-07-24")
const payment_cryptography = AWS.JSONService(
"payment-cryptography",
"controlplane.payment-cryptography",
"2021-09-14",
"1.0",
"PaymentCryptographyControlPlane",
)
const payment_cryptography_data = AWS.RestJSONService(
"payment-cryptography", "dataplane.payment-cryptography", "2022-02-03"
)
const pca_connector_ad = AWS.RestJSONService(
"pca-connector-ad", "pca-connector-ad", "2018-05-10"
)
const pca_connector_scep = AWS.RestJSONService(
"pca-connector-scep", "pca-connector-scep", "2018-05-10"
)
const personalize = AWS.JSONService(
"personalize", "personalize", "2018-05-22", "1.1", "AmazonPersonalize"
)
const personalize_events = AWS.RestJSONService(
"personalize", "personalize-events", "2018-03-22"
)
const personalize_runtime = AWS.RestJSONService(
"personalize", "personalize-runtime", "2018-05-22"
)
const pi = AWS.JSONService("pi", "pi", "2018-02-27", "1.1", "PerformanceInsightsv20180227")
const pinpoint = AWS.RestJSONService("mobiletargeting", "pinpoint", "2016-12-01")
const pinpoint_email = AWS.RestJSONService("ses", "email", "2018-07-26")
const pinpoint_sms_voice = AWS.RestJSONService(
"sms-voice", "sms-voice.pinpoint", "2018-09-05"
)
const pinpoint_sms_voice_v2 = AWS.JSONService(
"sms-voice", "sms-voice", "2022-03-31", "1.0", "PinpointSMSVoiceV2"
)
const pipes = AWS.RestJSONService("pipes", "pipes", "2015-10-07")
const polly = AWS.RestJSONService("polly", "polly", "2016-06-10")
const pricing = AWS.JSONService(
"pricing", "api.pricing", "2017-10-15", "1.1", "AWSPriceListService"
)
const privatenetworks = AWS.RestJSONService(
"private-networks", "private-networks", "2021-12-03"
)
const proton = AWS.JSONService("proton", "proton", "2020-07-20", "1.0", "AwsProton20200720")
const qbusiness = AWS.RestJSONService("qbusiness", "qbusiness", "2023-11-27")
const qconnect = AWS.RestJSONService("wisdom", "wisdom", "2020-10-19")
const qldb = AWS.RestJSONService("qldb", "qldb", "2019-01-02")
const qldb_session = AWS.JSONService(
"qldb", "session.qldb", "2019-07-11", "1.0", "QLDBSession"
)
const quicksight = AWS.RestJSONService("quicksight", "quicksight", "2018-04-01")
const ram = AWS.RestJSONService("ram", "ram", "2018-01-04")
const rbin = AWS.RestJSONService("rbin", "rbin", "2021-06-15")
const rds = AWS.QueryService("rds", "rds", "2014-10-31")
const rds_data = AWS.RestJSONService("rds-data", "rds-data", "2018-08-01")
const redshift = AWS.QueryService("redshift", "redshift", "2012-12-01")
const redshift_data = AWS.JSONService(
"redshift-data", "redshift-data", "2019-12-20", "1.1", "RedshiftData"
)
const redshift_serverless = AWS.JSONService(
"redshift-serverless", "redshift-serverless", "2021-04-21", "1.1", "RedshiftServerless"
)
const rekognition = AWS.JSONService(
"rekognition", "rekognition", "2016-06-27", "1.1", "RekognitionService"
)
const repostspace = AWS.RestJSONService("repostspace", "repostspace", "2022-05-13")
const resiliencehub = AWS.RestJSONService("resiliencehub", "resiliencehub", "2020-04-30")
const resource_explorer_2 = AWS.RestJSONService(
"resource-explorer-2", "resource-explorer-2", "2022-07-28"
)
const resource_groups = AWS.RestJSONService(
"resource-groups", "resource-groups", "2017-11-27"
)
const resource_groups_tagging_api = AWS.JSONService(
"tagging", "tagging", "2017-01-26", "1.1", "ResourceGroupsTaggingAPI_20170126"
)
const robomaker = AWS.RestJSONService("robomaker", "robomaker", "2018-06-29")
const rolesanywhere = AWS.RestJSONService("rolesanywhere", "rolesanywhere", "2018-05-10")
const route53_recovery_cluster = AWS.JSONService(
"route53-recovery-cluster",
"route53-recovery-cluster",
"2019-12-02",
"1.0",
"ToggleCustomerAPI",
)
const route53_recovery_control_config = AWS.RestJSONService(
"route53-recovery-control-config", "route53-recovery-control-config", "2020-11-02"
)
const route53_recovery_readiness = AWS.RestJSONService(
"route53-recovery-readiness", "route53-recovery-readiness", "2019-12-02"
)
const route53profiles = AWS.RestJSONService(
"route53profiles", "route53profiles", "2018-05-10"
)
const route53resolver = AWS.JSONService(
"route53resolver", "route53resolver", "2018-04-01", "1.1", "Route53Resolver"
)
const route_53 = AWS.RestXMLService("route53", "route53", "2013-04-01")
const route_53_domains = AWS.JSONService(
"route53domains", "route53domains", "2014-05-15", "1.1", "Route53Domains_v20140515"
)
const rum = AWS.RestJSONService("rum", "rum", "2018-05-10")
const s3 = AWS.RestXMLService("s3", "s3", "2006-03-01")
const s3_control = AWS.RestXMLService("s3", "s3-control", "2018-08-20")
const s3outposts = AWS.RestJSONService("s3-outposts", "s3-outposts", "2017-07-25")
const sagemaker = AWS.JSONService(
"sagemaker", "api.sagemaker", "2017-07-24", "1.1", "SageMaker"
)
const sagemaker_a2i_runtime = AWS.RestJSONService(
"sagemaker", "a2i-runtime.sagemaker", "2019-11-07"
)
const sagemaker_edge = AWS.RestJSONService("sagemaker", "edge.sagemaker", "2020-09-23")
const sagemaker_featurestore_runtime = AWS.RestJSONService(
"sagemaker", "featurestore-runtime.sagemaker", "2020-07-01"
)
const sagemaker_geospatial = AWS.RestJSONService(
"sagemaker-geospatial", "sagemaker-geospatial", "2020-05-27"
)
const sagemaker_metrics = AWS.RestJSONService(
"sagemaker", "metrics.sagemaker", "2022-09-30"
)
const sagemaker_runtime = AWS.RestJSONService(
"sagemaker", "runtime.sagemaker", "2017-05-13"
)
const savingsplans = AWS.RestJSONService("savingsplans", "savingsplans", "2019-06-28")
const scheduler = AWS.RestJSONService("scheduler", "scheduler", "2021-06-30")
const schemas = AWS.RestJSONService("schemas", "schemas", "2019-12-02")
const secrets_manager = AWS.JSONService(
"secretsmanager", "secretsmanager", "2017-10-17", "1.1", "secretsmanager"
)
const securityhub = AWS.RestJSONService("securityhub", "securityhub", "2018-10-26")
const securitylake = AWS.RestJSONService("securitylake", "securitylake", "2018-05-10")
const serverlessapplicationrepository = AWS.RestJSONService(
"serverlessrepo", "serverlessrepo", "2017-09-08"
)
const service_catalog = AWS.JSONService(
"servicecatalog", "servicecatalog", "2015-12-10", "1.1", "AWS242ServiceCatalogService"
)
const service_catalog_appregistry = AWS.RestJSONService(
"servicecatalog", "servicecatalog-appregistry", "2020-06-24"
)
const service_quotas = AWS.JSONService(
"servicequotas", "servicequotas", "2019-06-24", "1.1", "ServiceQuotasV20190624"
)
const servicediscovery = AWS.JSONService(
"servicediscovery",
"servicediscovery",
"2017-03-14",
"1.1",
"Route53AutoNaming_v20170314",
)
const ses = AWS.QueryService("ses", "email", "2010-12-01")
const sesv2 = AWS.RestJSONService("ses", "email", "2019-09-27")
const sfn = AWS.JSONService("states", "states", "2016-11-23", "1.0", "AWSStepFunctions")
const shield = AWS.JSONService(
"shield", "shield", "2016-06-02", "1.1", "AWSShield_20160616"
)
const signer = AWS.RestJSONService("signer", "signer", "2017-08-25")
const simpledb = AWS.QueryService("sdb", "sdb", "2009-04-15")
const simspaceweaver = AWS.RestJSONService("simspaceweaver", "simspaceweaver", "2022-10-28")
const sms = AWS.JSONService(
"sms", "sms", "2016-10-24", "1.1", "AWSServerMigrationService_V2016_10_24"
)
const snow_device_management = AWS.RestJSONService(
"snow-device-management", "snow-device-management", "2021-08-04"
)
const snowball = AWS.JSONService(
"snowball", "snowball", "2016-06-30", "1.1", "AWSIESnowballJobManagementService"
)
const sns = AWS.QueryService("sns", "sns", "2010-03-31")
const sqs = AWS.JSONService("sqs", "sqs", "2012-11-05", "1.0", "AmazonSQS")
const ssm = AWS.JSONService("ssm", "ssm", "2014-11-06", "1.1", "AmazonSSM")
const ssm_contacts = AWS.JSONService(
"ssm-contacts", "ssm-contacts", "2021-05-03", "1.1", "SSMContacts"
)
const ssm_incidents = AWS.RestJSONService("ssm-incidents", "ssm-incidents", "2018-05-10")
const ssm_sap = AWS.RestJSONService("ssm-sap", "ssm-sap", "2018-05-10")
const sso = AWS.RestJSONService("awsssoportal", "portal.sso", "2019-06-10")
const sso_admin = AWS.JSONService("sso", "sso", "2020-07-20", "1.1", "SWBExternalService")
const sso_oidc = AWS.RestJSONService("sso-oauth", "oidc", "2019-06-10")
const storage_gateway = AWS.JSONService(
"storagegateway", "storagegateway", "2013-06-30", "1.1", "StorageGateway_20130630"
)
const sts = AWS.QueryService("sts", "sts", "2011-06-15")
const supplychain = AWS.RestJSONService("scn", "scn", "2024-01-01")
const support = AWS.JSONService(
"support", "support", "2013-04-15", "1.1", "AWSSupport_20130415"
)
const support_app = AWS.RestJSONService("supportapp", "supportapp", "2021-08-20")
const swf = AWS.JSONService("swf", "swf", "2012-01-25", "1.0", "SimpleWorkflowService")
const synthetics = AWS.RestJSONService("synthetics", "synthetics", "2017-10-11")
const taxsettings = AWS.RestJSONService("tax", "tax", "2018-05-10")
const textract = AWS.JSONService("textract", "textract", "2018-06-27", "1.1", "Textract")
const timestream_influxdb = AWS.JSONService(
"timestream-influxdb",
"timestream-influxdb",
"2023-01-27",
"1.0",
"AmazonTimestreamInfluxDB",
)
const timestream_query = AWS.JSONService(
"timestream", "query.timestream", "2018-11-01", "1.0", "Timestream_20181101"
)
const timestream_write = AWS.JSONService(
"timestream", "ingest.timestream", "2018-11-01", "1.0", "Timestream_20181101"
)
const tnb = AWS.RestJSONService("tnb", "tnb", "2008-10-21")
const transcribe = AWS.JSONService(
"transcribe", "transcribe", "2017-10-26", "1.1", "Transcribe"
)
const transfer = AWS.JSONService(
"transfer", "transfer", "2018-11-05", "1.1", "TransferService"
)
const translate = AWS.JSONService(
"translate", "translate", "2017-07-01", "1.1", "AWSShineFrontendService_20170701"
)
const trustedadvisor = AWS.RestJSONService("trustedadvisor", "trustedadvisor", "2022-09-15")
const verifiedpermissions = AWS.JSONService(
"verifiedpermissions", "verifiedpermissions", "2021-12-01", "1.0", "VerifiedPermissions"
)
const voice_id = AWS.JSONService("voiceid", "voiceid", "2021-09-27", "1.0", "VoiceID")
const vpc_lattice = AWS.RestJSONService("vpc-lattice", "vpc-lattice", "2022-11-30")
const waf = AWS.JSONService("waf", "waf", "2015-08-24", "1.1", "AWSWAF_20150824")
const waf_regional = AWS.JSONService(
"waf-regional", "waf-regional", "2016-11-28", "1.1", "AWSWAF_Regional_20161128"
)
const wafv2 = AWS.JSONService("wafv2", "wafv2", "2019-07-29", "1.1", "AWSWAF_20190729")
const wellarchitected = AWS.RestJSONService(
"wellarchitected", "wellarchitected", "2020-03-31"
)
const wisdom = AWS.RestJSONService("wisdom", "wisdom", "2020-10-19")
const workdocs = AWS.RestJSONService("workdocs", "workdocs", "2016-05-01")
const worklink = AWS.RestJSONService("worklink", "worklink", "2018-09-25")
const workmail = AWS.JSONService(
"workmail", "workmail", "2017-10-01", "1.1", "WorkMailService"
)
const workmailmessageflow = AWS.RestJSONService(
"workmailmessageflow", "workmailmessageflow", "2019-05-01"
)
const workspaces = AWS.JSONService(
"workspaces", "workspaces", "2015-04-08", "1.1", "WorkspacesService"
)
const workspaces_thin_client = AWS.RestJSONService("thinclient", "thinclient", "2023-08-22")
const workspaces_web = AWS.RestJSONService("workspaces-web", "workspaces-web", "2020-07-08")
const xray = AWS.RestJSONService("xray", "xray", "2016-04-12")
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 7780 | """
IMDS
Front-end for retrieving AWS instance metadata via the Instance Metadata Service (IMDS). For
details on available metadata see the official AWS documentation on:
["Instance metadata and user data"](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html).
The IMDS module supports instances using either IMDSv1 or IMDSv2 (preferring IMDSv2 for
security reasons).
"""
module IMDS
using ..AWSExceptions: IMDSUnavailable
using HTTP: HTTP
using HTTP.Exceptions: ConnectError, StatusError
using Mocking
using URIs: URI
# Local-link address (https://en.wikipedia.org/wiki/Link-local_address)
const IPv4_ADDRESS = "169.254.169.254"
const DEFAULT_DURATION = 600 # 5 minutes, in seconds
mutable struct Session
token::String
duration::Int16
expiration::Int64
end
const _SESSION = Ref{Session}()
function __init__()
_SESSION[] = Session()
return nothing
end
"""
Session(; duration=$DEFAULT_DURATION)
An IMDS `Session` which retains the IMDSv2 token over multiple requests. When IMDSv2 is
unavailable the session switches to IMDSv1 mode and avoids future requests for IMDSv2
tokens.
# Keywords
- `duration` (optional): Requested session duration, in seconds, for the IMDSv2 token. Can
be a minimum of one second and a maximum of six hours (21600).
"""
Session(; duration=DEFAULT_DURATION) = Session("", duration, 0)
token_expired(session::Session; drift=10) = time() - session.expiration - drift > 0
function refresh_token!(session::Session, duration::Integer=session.duration)
t = floor(Int64, time())
headers = ["X-aws-ec2-metadata-token-ttl-seconds" => string(duration)]
# For IMDSv2, you must use `/latest/api/token` when retrieving the token instead of a
# version specific path.
# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html#imds-considerations
uri = URI(; scheme="http", host=IPv4_ADDRESS, path="/latest/api/token")
r = try
_http_request("PUT", uri, headers; status_exception=false)
catch e
# The IMDSv2 uses a default Time To Live (TTL) of 1 (also known as the hop limit) at
# the IP layer to ensure token requests occur on the instance. When this occurs we
# need to fall back to using IMDSv1. Users may wish to increase the hop limit to
# allow for IMDSv2 use in container based environments:
# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html#imds-considerations
if is_ttl_expired_exception(e)
@warn "IMDSv2 token request rejected due to reaching hop limit. Consider " *
"increasing the hop limit to avoid delays upon initial use:\n" *
"https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/" *
"instancedata-data-retrieval.html#imds-considerations"
session.duration = 0
session.expiration = typemax(Int64) # Use IMDSv1 indefinitely
return session
else
rethrow()
end
end
# Store the session token when we receive an HTTP 200. If we receive an HTTP 404 assume
# that the server is only supports IMDSv1. Otherwise "rethrow" the `StatusError`.
if r.status == 200
session.token = String(r.body)
session.duration = duration
session.expiration = t + duration
elseif r.status == 404
session.duration = 0
session.expiration = typemax(Int64) # Use IMDSv1 indefinitely
else
# Could also populate the `StatusError` via `r.request.method` and
# `r.request.target` however `r.request` may not be populated under test scenarios.
throw(StatusError(r.status, "PUT", uri.path, r))
end
return session
end
function request(session::Session, method::AbstractString, path::AbstractString; kwargs...)
# Attempt to generate token for use with IMDSv2. If we're unable to generate a token
# we'll fall back on using IMDSv1. We prefer using IMDSv2 as instances can be configured
# to disable IMDSv1 access: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-IMDS-new-instances.html#configure-IMDS-new-instances
token_expired(session) && refresh_token!(session)
headers = Pair{String,String}[]
!isempty(session.token) && push!(headers, "X-aws-ec2-metadata-token" => session.token)
# Only using the IPv4 endpoint as the IPv6 endpoint has to be explicitly enabled and
# does not disable IPv4 support.
# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-IMDS-new-instances.html#configure-IMDS-new-instances-ipv4-ipv6-endpoints
uri = URI(; scheme="http", host=IPv4_ADDRESS, path)
return _http_request(method, uri, headers; kwargs...)
end
function _http_request(args...; status_exception=true, kwargs...)
response = try
# Always throw status exceptions so we can determine if the IMDS service is available
@mock HTTP.request(
args...; connect_timeout=1, retry=false, kwargs..., status_exception=true
)
catch e
# When running outside of an EC2 instance the link-local address will be unavailable
# and connections will fail. On EC2 instances where IMDS is disabled a HTTP 403 is
# returned.
# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html#instance-metadata-returns
if is_connection_exception(e) || e isa StatusError && e.status == 403
throw(IMDSUnavailable())
#! format: off
# Return the status exception when `status_exception=false`. We must always cause
# `HTTP.request` to throw status errors for our `IMDSUnavailable` check.
#! format: on
elseif !status_exception && e isa StatusError
e.response
else
rethrow()
end
end
return response
end
is_connection_exception(e::ConnectError) = true
is_connection_exception(e::Exception) = false
# https://github.com/JuliaCloud/AWS.jl/issues/654
# https://github.com/JuliaCloud/AWS.jl/issues/649
function is_ttl_expired_exception(e::HTTP.Exceptions.RequestError)
return e.error == Base.IOError("read: connection timed out (ETIMEDOUT)", -110)
end
is_ttl_expired_exception(e::Exception) = false
"""
get([session::Session], path::AbstractString) -> Union{String, Nothing}
Retrieve the AWS instance metadata from the provided HTTP `path`. If the specific metadata
resource is unavailable or the instance metadata is unavailable (due to the instance metadata
service being disabled or not being run from within an EC2 instance) then `nothing` will be
returned. For details on available metadata see the official AWS documentation on:
["Instance metadata and user data"](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html).
# Arguments
- `session` (optional): The IMDS `Session` used to store the IMDSv2 token.
- `path`: The HTTP path to used to specify the metadata to return.
"""
function get(session::Session, path::AbstractString)
response = try
request(session, "GET", path)
catch e
if e isa IMDSUnavailable || e isa StatusError && e.status == 404
nothing
else
rethrow()
end
end
return !isnothing(response) ? String(response.body) : nothing
end
get(path::AbstractString) = get(_SESSION[], path)
"""
region([session::Session]) -> Union{String, Nothing}
Determine the AWS region of the machine executing this code if running inside of an EC2
instance, otherwise `nothing` is returned.
# Arguments
- `session` (optional): The IMDS `Session` used to store the IMDSv2 token.
"""
region(session::Session) = get(session, "/latest/meta-data/placement/region")
region() = region(_SESSION[])
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 8584 | # Emulates the legacy `use_response_type=false` response behavior using the `AWS.Response`
function legacy_response(
request::AWS.Request, response::AWS.Response; return_headers=nothing
)
response_dict_type = something(request.response_dict_type, LittleDict)
return_headers = something(return_headers, false)
# When a user defined I/O stream is passed in use the actual `HTTP.Response` body
# instead of the `AWS.Response` body which requires the I/O stream to be seekable.
body = if request.response_stream !== nothing
b"[Message Body was streamed]"
else
response.body
end
# The stored service name is always lowercase and may not match the module name
# specified by the user. We'll assume that the typical casing used is titlecase.
alt_service = "@service $(titlecase(request.service)) use_response_type=true"
# When a user specifies a `response_dict_type` we'll update the deprecations to show how
# to use this type.
# Note: Using overly terse function name to stick within line length. A more descriptive
# function name would be `response_dict_type_str`.
tstr = if request.response_dict_type !== nothing
str -> "$(request.response_dict_type)($str)"
else
identity
end
# For HEAD request, return headers...
if request.request_method == "HEAD"
Base.depwarn(
"Using \"HEAD\" in AWS requests to return headers is deprecated, " *
"use `$alt_service` to return an `AWS.Response` allowing for " *
"header access via " *
"`$(tstr("response.headers"))`.",
:legacy_response,
)
return response_dict_type(response.headers)
end
# Return response stream if requested...
if something(request.return_stream, false)
Base.depwarn(
"The keyword `return_stream` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"streaming access via `response.io`.",
:legacy_response,
)
# When `return_stream` was `true` the backends would create different I/O types to
# use. We'll replicate that behavior.
if request.response_stream === nothing
io = if request.backend isa HTTPBackend
Base.BufferStream()
else
IOBuffer()
end
write(io, _rewind(read, response.io))
request.response_stream = io
end
# Emulate HTTP 0.9.14 behavior of always closing the passed in stream. Doing this is
# particularly important for `Base.BufferStream`.
if request.backend isa HTTPBackend
close(request.response_stream)
end
return request.response_stream
elseif request.response_stream !== nothing
# Emulate HTTP 0.9.14 behavior of always closing the passed in stream and the
# `read_body` behavior of closing all non-`IOBuffer` streams when `return_stream` is
# not `true`. Doing this is particularly important for `Base.BufferStream`.
if request.backend isa HTTPBackend || !(request.response_stream isa IOBuffer)
close(request.response_stream)
end
end
# Return raw data if requested...
if something(request.return_raw, false)
if return_headers
Base.depwarn(
"The keywords `return_raw` and `return_headers` are deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw data and header access via " *
"`response.body`/`response.header`.",
:legacy_response,
)
else
Base.depwarn(
"The keyword `return_raw` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw data access via " *
"`response.body`.",
:legacy_response,
)
end
return (return_headers ? (body, response.headers) : body)
end
# Parse response data according to mimetype...
mime = HTTP.header(response.response, "Content-Type", "")
if isempty(mime)
if length(body) > 5 && body[1:5] == b"<?xml"
mime = "text/xml"
end
end
body_str = String(copy(body))
if isempty(body_str)
return (
if return_headers
(nothing, response_dict_type(response.headers))
else
nothing
end
)
elseif occursin(r"/xml", mime)
if return_headers
Base.depwarn(
"The keyword `return_headers` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"parsed XML and header access via " *
"`$(tstr("parse(response)"))`/`$(tstr("response.header"))` respectively",
:legacy_response,
)
else
Base.depwarn(
"Returning the parsed AWS response is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"parsed XML access via " *
"`$(tstr("parse(response.body)"))`.",
:legacy_response,
)
end
xml_dict_type = response_dict_type{Union{Symbol,String},Any}
xml = parse_xml(body_str)
root = XMLDict.root(xml.x)
return (
if return_headers
(xml_dict(root, xml_dict_type), response_dict_type(response.headers))
else
xml_dict(root, xml_dict_type)
end
)
elseif occursin(r"/x-amz-json-1.[01]$", mime) || endswith(mime, "json")
if return_headers
Base.depwarn(
"The keyword `return_headers` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"parsed JSON and header access via " *
"`$(tstr("parse(response)"))`/`$(tstr("response.header"))` respectively",
:legacy_response,
)
else
Base.depwarn(
"Returning the parsed AWS response is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"parsed JSON access via " *
"`$(tstr("parse(response.body)"))`.",
:legacy_response,
)
end
info = isempty(body) ? nothing : JSON.parse(body_str; dicttype=response_dict_type)
return (return_headers ? (info, response_dict_type(response.headers)) : info)
elseif startswith(mime, "text/")
if return_headers
Base.depwarn(
"The keyword `return_headers` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw string data and header access via " *
"`String(response.body)`/`$(tstr("response.header"))` respectively.",
:legacy_response,
)
else
Base.depwarn(
"Returning the raw AWS response body is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw string data access via " *
"`String(response.body)`.",
:legacy_response,
)
end
return (
return_headers ? (body_str, response_dict_type(response.headers)) : body_str
)
else
if return_headers
Base.depwarn(
"The keyword `return_headers` is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw data and header access via " *
"`response.body`/`response.header` respectively.",
:legacy_response,
)
else
Base.depwarn(
"Returning the raw AWS response body is deprecated, " *
"use `$alt_service` instead to return an `AWS.Response` allowing for " *
"raw data access via " *
"`response.body`.",
:legacy_response,
)
end
return (return_headers ? (body, response.headers) : body)
end
end
@deprecate ec2_instance_metadata(path::AbstractString) IMDS.get(path)
@deprecate ec2_instance_region() IMDS.region()
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 13976 | """
Generate the `src/services/{service}.jl` file.
"""
function _generate_high_level_wrapper(
service_files::AbstractArray{ServiceFile}, auth::GitHub.OAuth2
)
service_dir = joinpath(@__DIR__, "..", "services")
# Remove old service files to ensure services that no longer exist are removed.
for file in readdir(service_dir)
path = joinpath(service_dir, file)
if endswith(path, ".jl")
rm(path)
end
end
Threads.@threads for service_file in service_files
service_name = service_file.name
@info "Generating high level wrapper for $service_name"
service = service_definition(service_file; auth=auth)
service_name = lowercase(service["metadata"]["serviceId"])
service_name = replace(service_name, ' ' => '_')
operations = service["operations"]
shapes = service["shapes"]
protocol = service["metadata"]["protocol"]
operations = sort!(
_generate_high_level_definitions(service_name, protocol, operations, shapes)
)
service_path = joinpath(service_dir, "$service_name.jl")
open(service_path, "w") do f
println(
f,
"""
# This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: $service_name
using AWS.Compat
using AWS.UUIDs
""",
)
join(f, operations, "\n")
end
end
end
"""
Generate high-level definitions for the `service`.
All high-level definitions and documentation to be written into `services/{Service}.jl`
"""
function _generate_high_level_definitions(
service_name::String, protocol::String, operations::AbstractDict, shapes::AbstractDict
)
operation_definitions = String[]
for (_, operation) in operations
name = operation["name"]
method = operation["http"]["method"]
request_uri = operation["http"]["requestUri"]
documentation = ""
if haskey(operation, "documentation")
documentation = _clean_documentation(operation["documentation"])
end
required_parameters = Dict{String,Any}()
optional_parameters = Dict{String,Any}()
if haskey(operation, "input")
required_parameters, optional_parameters = _get_function_parameters(
operation["input"]["shape"], shapes
)
end
operation_definition = _generate_high_level_definition(
service_name,
protocol,
name,
method,
request_uri,
required_parameters,
optional_parameters,
documentation,
)
push!(operation_definitions, operation_definition)
end
return operation_definitions
end
"""
Generate the high-level definition for a services function.
"""
function _generate_high_level_definition(
service_name::String,
protocol::String,
name::String,
method::String,
request_uri::String,
required_parameters::AbstractDict,
optional_parameters::AbstractDict,
documentation::String,
)
"""
Generate function definition for a service request given required, header and idempotent parameters.
"""
function _generate_rest_operation_defintion(
required_params::AbstractDict,
optional_params::AbstractDict,
function_name::String,
service_name::String,
method::String,
request_uri::String,
)
request_uri = replace(request_uri, '{' => "\$(") # Replace { with $(
request_uri = replace(request_uri, '}' => ')') # Replace } with )
request_uri = replace(request_uri, '+' => "") # Remove + from the request URI
# Pre Julia-1.3 workaround
req_keys = [replace(key, "-" => "_") for key in collect(keys(required_params))]
required_params = filter(p -> (p[2]["location"] != "uri"), required_params)
header_params = filter(p -> (p[2]["location"] == "header"), required_params)
required_params = setdiff(required_params, header_params)
idempotent_params = filter(p -> (p[2]["idempotent"]), optional_params)
req_kv = ["\"$(p[1])\"=>$(replace(p[1], "-" => "_"))" for p in required_params]
header_kv = ["\"$(p[1])\"=>$(replace(p[1], "-" => "_"))" for p in header_params]
idempotent_kv = ["\"$(p[1])\"=>string(uuid4())" for p in idempotent_params]
required_keys = !isempty(req_keys)
headers = !isempty(header_params)
idempotent = !isempty(idempotent_params)
req_str = !isempty(req_kv) ? "Dict{String, Any}($(join(req_kv, ", "))" : ""
params_str = if (!isempty(req_kv) || idempotent)
"$(join(vcat(req_kv, idempotent_kv), ", "))"
else
""
end
headers_str =
headers ? "\"headers\"=>Dict{String, Any}($(join(header_kv, ", ")))" : ""
params_headers_str = "Dict{String, Any}($(join([s for s in (params_str, headers_str) if !isempty(s)], ", ")))"
formatted_function_name = _format_name(function_name)
if required_keys && (idempotent || headers)
return """
$formatted_function_name($(join(req_keys, ", ")); aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", $params_headers_str; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name($(join(req_keys, ", ")), params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", Dict{String, Any}(mergewith(_merge, $params_headers_str, params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
elseif !required_keys && (idempotent || headers)
return """
$formatted_function_name(; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", $params_headers_str; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", Dict{String, Any}(mergewith(_merge, $params_headers_str, params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
elseif required_keys && !isempty(req_kv)
return """
$formatted_function_name($(join(req_keys, ", ")); aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", $req_str); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name($(join(req_keys, ", ")), params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", Dict{String, Any}(mergewith(_merge, $req_str), params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
elseif required_keys
return """
$formatted_function_name($(join(req_keys, ", ")); aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name($(join(req_keys, ", ")), params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
else
return """
$formatted_function_name(; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$method\", \"$request_uri\", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
end
end
"""
Generate a JSON/Query high level definition.
"""
function _generate_json_query_opeation_definition(
required_params::AbstractDict,
optional_params::AbstractDict,
function_name::String,
service_name::String,
)
req_keys = [replace(key, '-' => '_') for key in collect(keys(required_params))]
idempotent_params = filter(p -> (p[2]["idempotent"]), optional_params)
req_kv = ["\"$(p[1])\"=>$(replace(p[1], "-" => "_"))" for p in required_params]
idempotent_kv = ["\"$(p[1])\"=>string(uuid4())" for p in idempotent_params]
required = !isempty(req_kv)
idempotent = !isempty(idempotent_kv)
formatted_function_name = _format_name(function_name)
if required && idempotent
return """
$formatted_function_name($(join(req_keys, ", ")); aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}($(join(req_kv, ", ")), $(join(idempotent_kv, ", "))); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name($(join(req_keys, ", ")), params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}(mergewith(_merge, Dict{String, Any}($(join(req_kv, ", ")), $(join(idempotent_kv, ", "))), params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
elseif required
return """
$formatted_function_name($(join(req_keys, ", ")); aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}($(join(req_kv, ", "))); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name($(join(req_keys, ", ")), params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}(mergewith(_merge, Dict{String, Any}($(join(req_kv, ", "))), params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
elseif idempotent
return """
$formatted_function_name(; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}($(join(idempotent_kv, ", "))); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", Dict{String, Any}(mergewith(_merge, Dict{String, Any}($(join(idempotent_kv, ", "))), params)); aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
else
return """
$formatted_function_name(; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
$formatted_function_name(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = $service_name(\"$function_name\", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
"""
end
end
"""
Generate the docstring for the `function_name`.
"""
function _generate_docstring(
function_name, documentation, required_parameters, optional_parameters
)
function_name = _format_name(function_name)
args = join((_format_name(key) for (key, val) in required_parameters), ", ")
maybejoin = isempty(args) ? "" : ", "
operation_definition = """
$(repeat('"', 3))
$function_name($(args))
$function_name($(args)$(maybejoin)params::Dict{String,<:Any})
$(_wraplines(documentation))\n
"""
# Add in the required parameters if applicable
if !isempty(required_parameters)
operation_definition *= "# Arguments\n"
for (required_key, required_value) in required_parameters
key = _format_name(required_key)
operation_definition *= _wraplines(
"- `$key`: $(required_value["documentation"])"; delim="\n "
)
operation_definition *= "\n"
end
operation_definition *= "\n"
end
# Add in the optional parameters if applicable
if !isempty(optional_parameters)
operation_definition *= """
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
"""
for (optional_key, optional_value) in optional_parameters
operation_definition *= _wraplines(
"- `\"$optional_key\"`: $(optional_value["documentation"])";
delim="\n ",
)
operation_definition *= "\n"
end
end
return operation_definition *= repeat('"', 3)
end
doc_string = _generate_docstring(
name, documentation, required_parameters, optional_parameters
)
if protocol in ("json", "query", "ec2")
function_string = _generate_json_query_opeation_definition(
required_parameters, optional_parameters, name, service_name
)
elseif protocol in ("rest-json", "rest-xml")
function_string = _generate_rest_operation_defintion(
required_parameters,
optional_parameters,
name,
service_name,
method,
request_uri,
)
else
throw(
ProtocolNotDefined(
"$function_name is using a new protocol; $protocol which is not supported."
),
)
end
return string(doc_string, '\n', function_string)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 3005 | """
Generate the low-level `src/AWSServices.jl` file with all definitions.
"""
function _generate_low_level_wrappers(
service_files::AbstractArray{ServiceFile}, auth::GitHub.Authorization
)
service_definitions = sort!(_generate_low_level_definitions(service_files, auth))
template = """
# This file is auto-generated by AWSMetadata.jl
module AWSServices
using AWS
using OrderedCollections: LittleDict
$(join(service_definitions, "\n"))
end
"""
open(services_path, "w") do f
print(f, template)
end
return template
end
"""
Get the low-level definitions for all AWS Services.
"""
function _generate_low_level_definitions(
service_files::AbstractArray{ServiceFile}, auth::GitHub.Authorization
)
low_level_defs = Vector{String}(undef, length(service_files))
Threads.@threads for i in eachindex(service_files)
service_file = service_files[i]
service_name = service_file.name
@info "Generating low level wrapper for $service_name"
service = service_definition(service_file; auth=auth)
service_metadata = service["metadata"]
low_level_defs[i] = _generate_low_level_definition(service_metadata)
end
return low_level_defs
end
"""
Get the low-level definition for an AWS Service.
"""
function _generate_low_level_definition(service::AbstractDict)
protocol = service["protocol"]
endpoint_prefix = service["endpointPrefix"]
signing_name =
haskey(service, "signingName") ? service["signingName"] : service["endpointPrefix"]
service_id = replace(lowercase(service["serviceId"]), ' ' => '_')
api_version = service["apiVersion"]
service_specifics = LittleDict{String,String}()
if service_id == "glacier"
service_specifics[service_id] = "LittleDict(\"x-amz-glacier-version\" => \"$(service["apiVersion"])\")"
end
if protocol == "rest-xml"
return "const $service_id = AWS.RestXMLService(\"$signing_name\", \"$endpoint_prefix\", \"$api_version\")"
elseif protocol in ("ec2", "query")
return "const $service_id = AWS.QueryService(\"$signing_name\", \"$endpoint_prefix\", \"$api_version\")"
elseif protocol == "rest-json" && haskey(service_specifics, service_id)
return "const $service_id = AWS.RestJSONService(\"$signing_name\", \"$endpoint_prefix\", \"$api_version\", $(service_specifics[service_id]))"
elseif protocol == "rest-json"
return "const $service_id = AWS.RestJSONService(\"$signing_name\", \"$endpoint_prefix\", \"$api_version\")"
elseif protocol == "json"
json_version = service["jsonVersion"]
target = service["targetPrefix"]
return "const $service_id = AWS.JSONService(\"$signing_name\", \"$endpoint_prefix\", \"$api_version\", \"$json_version\", \"$target\")"
else
throw(
ProtocolNotDefined(
"$service_id is using a new protocol; $protocol which is not supported."
),
)
end
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 9367 | mutable struct ServiceFile
repo::String
name::String
sha::String
definition::Union{AbstractDict,Nothing}
end
function ServiceFile(repo::String, tree_item::AbstractDict)
return ServiceFile(repo, tree_item["path"], tree_item["sha"], nothing)
end
function service_definition(
service_file::ServiceFile; auth::GitHub.Authorization=GitHub.AnonymousAuth()
)
if service_file.definition === nothing
# Retrieve the contents of the ${service}.normal.json file
service_blob = blob(service_file.repo, service_file.sha; auth=auth)
def = JSON.parse(String(base64decode(service_blob.content)))
service_file.definition = def
end
return service_file.definition
end
function Base.:(==)(a::ServiceFile, b::ServiceFile)
return (
a.repo == b.repo &&
a.name == b.name &&
a.sha == b.sha &&
a.definition == b.definition
)
end
"""
Get a list of all AWS service API definition files from the `awsk-sdk-js` GitHub repository.
"""
function _get_service_files(repo_name::String, auth::GitHub.Authorization)
master_tree = @mock tree(repo_name, "master"; auth=auth)
apis_sha = [t for t in master_tree.tree if t["path"] == "apis"][1]["sha"]
files = @mock tree(repo_name, apis_sha)
tree_items = files.tree
filter!(f -> endswith(f["path"], ".normal.json"), tree_items)
tree_items = _filter_latest_service_version(tree_items)
return [ServiceFile(repo_name, item) for item in tree_items]
end
"""
Return a list of all AWS Services and their latest version.
"""
function _filter_latest_service_version(services::AbstractArray)
seen_services = Set{String}()
latest_versions = OrderedDict[]
for service in reverse(services)
service_name, _ = _get_service_and_version(service["path"])
if !(service_name in seen_services)
push!(seen_services, service_name)
push!(latest_versions, service)
end
end
return latest_versions
end
"""
Return a string with line breaks added such that lines are wrapped at or before the limit.
"""
function _wraplines(str, limit=92; delim="\n")
lines = String[]
while !isempty(str)
line, str = _splitline(str, limit)
push!(lines, rstrip(line)) # strip trailing whitespace
end
return join(lines, delim)
end
"""
Split the string `str` at or before `limit`.
Prefers splitting the string on whitespace rather than mid-word, when possible.
`limit` is measured in codeunits, which is an upper-bound on the number of characters.
"""
function _splitline(str, limit)
limit >= 1 || throw(DomainError(limit, "Lines cannot be split before the first char."))
ncodeunits(str) <= limit && return (str, "")
limit = _validindex(str, limit)
first_line = str[1:limit]
# split on whitespace if possible, else just split when we hit the limit.
split_point = something(findlast(==(' '), first_line), limit)
stop = _validindex(first_line, split_point)
while ispunct(first_line[stop]) # avoid splitting escaped characters.
stop = prevind(first_line, stop)
end
restart = nextind(first_line, stop)
return (str[1:stop], str[restart:end])
end
"""
Return a valid index into the string `str`, rounding towards the first index of `str` if `i` is not itself a valid index into `str`.
`i` must be within the bounds of `string`. `_validindex(str, i)` only protects against a `StringIndexError`, not a `BoundsError`.
"""
function _validindex(str, limit)
prev = max(firstindex(str), prevind(str, limit))
next = nextind(str, prev)
return next == limit ? limit : prev
end
"""
Convert a function name from CamelCase to snake_case
"""
function _format_name(function_name::String)
# Replace a string of uppercase characters with themselves prefaced by an underscore
# [A-Z](?![A-Z]) => Match a single uppercase character that is not followed by another uppercase character
# |(A-Z]{1,}) => Match 1-Infinite amounts of uppercase characters
function_name = replace(function_name, r"[A-Z](?![A-Z])|([A-Z]{1,})" => s"_\g<0>")
# Lowercase the entire string
function_name = lowercase(function_name)
# Chop off the leading underscore
return if startswith(function_name, "_")
chop(function_name; head=1, tail=0)
else
function_name
end
end
"""
Replace URI parameters with the appropriate syntax for Julia interpolation.
Find all URI parameters, and apply the following replacements:
* { => \$(
* } => )
* - => _
* + => empty string
Example: "/v1/configurations/{configuration-id}" => "/v1/configurations/\$(configuration_id)"
"""
function _clean_uri(uri::String)
uri_parameters = eachmatch(r"{.*?}", uri) # Match anything surrounded in "{ }"
for param in uri_parameters
match = param.match
original_match = match
match = replace(match, '{' => "\$(") # Replace { with $(
match = replace(match, '}' => ')') # Replace } with )
match = replace(match, '-' => '_') # Replace hyphens with underscores
match = replace(match, '+' => "") # Remove +
uri = replace(uri, original_match => match)
end
return uri
end
"""
Clean up the documentation to make it Julia compiler and human-readable.
* Remove any HTML tags
* Remove any dollar signs
* Remove any backslashes
* Escape any double-quotes
"""
function _clean_documentation(documentation::String)
documentation = replace(documentation, r"\<.*?\>" => "")
documentation = replace(documentation, '$' => "")
documentation = replace(documentation, '\\' => "")
documentation = replace(documentation, '"' => "\\\"")
return documentation
end
"""
Get the `service` and `version` from a filename.
Example filename: `{Service}-{Version}.normal.json`
"""
function _get_service_and_version(filename::String)
try
# Remove ".normal.json" suffix
service_and_version = join(split(filename, '.')[1:(end - 2)], '.')
service_and_version = split(service_and_version, '-')
service = join(service_and_version[1:(end - 3)], '-')
version = join(service_and_version[(end - 2):end], '-')
return (service, version)
catch e
if e isa BoundsError
throw(InvalidFileName("$filename is an invalid AWS JSON filename."))
else
rethrow()
end
end
end
"""
Get the required and optional parameters for a given operation.
"""
function _get_function_parameters(input::String, shapes::AbstractDict{String})
"""
_get_parameter_name(parameter::String, input_shape::AbstractDict{String, <:Any})
Find the correct parameter name for making requests. Certain ones have a specific locationName, for Batch requests this locationName is nested one shape deeper.
# Arguments
- `parameter::String`: Name of the original parameter
- `input_shape::AbstractDict{String, <:Any}`: The parameter shape
# Returns
- `String`: Either the original parameter name, the locationName for the parameter, or the locationName nested one shape deeper
"""
function _get_parameter_name(parameter::String, input_shape::AbstractDict{String,<:Any})
# If the parameter has a locationName, return it
if haskey(input_shape["members"][parameter], "locationName")
return input_shape["members"][parameter]["locationName"]
end
# Check to see if the nested shape has a locationName
nested_shape = input_shape["members"][parameter]["shape"]
nested_member = get(shapes[nested_shape], "member", Dict())
# If nested_shape[member] exists return locationName (if exists), otherwise return the original parameter name
return get(nested_member, "locationName", parameter)
end
required_parameters = LittleDict{String,Any}()
optional_parameters = LittleDict{String,Any}()
input_shape = shapes[input]
if haskey(input_shape, "required")
for parameter in input_shape["required"]
parameter_name = _get_parameter_name(parameter, input_shape)
# Check if the parameter needs to be in a certain place
parameter_location = get(input_shape["members"][parameter], "location", "")
documentation = _clean_documentation(
get(input_shape["members"][parameter], "documentation", "")
)
required_parameters[parameter_name] = LittleDict{String,String}(
"location" => parameter_location, "documentation" => documentation
)
end
end
if haskey(input_shape, "members")
for (member_key, member_value) in input_shape["members"]
parameter_name = get(
input_shape["members"][member_key], "locationName", member_key
)
if !haskey(required_parameters, parameter_name)
documentation = _clean_documentation(get(member_value, "documentation", ""))
idempotent = get(member_value, "idempotencyToken", false)
optional_parameters[parameter_name] = LittleDict{String,Union{String,Bool}}(
"documentation" => documentation, "idempotent" => idempotent
)
end
end
end
return (sort(required_parameters), sort(optional_parameters))
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 52378 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: accessanalyzer
using AWS.Compat
using AWS.UUIDs
"""
apply_archive_rule(analyzer_arn, rule_name)
apply_archive_rule(analyzer_arn, rule_name, params::Dict{String,<:Any})
Retroactively applies the archive rule to existing findings that meet the archive rule
criteria.
# Arguments
- `analyzer_arn`: The Amazon resource name (ARN) of the analyzer.
- `rule_name`: The name of the rule to apply.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function apply_archive_rule(
analyzerArn, ruleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/archive-rule",
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"ruleName" => ruleName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function apply_archive_rule(
analyzerArn,
ruleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/archive-rule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"ruleName" => ruleName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_policy_generation(job_id)
cancel_policy_generation(job_id, params::Dict{String,<:Any})
Cancels the requested policy generation.
# Arguments
- `job_id`: The JobId that is returned by the StartPolicyGeneration operation. The JobId
can be used with GetGeneratedPolicy to retrieve the generated policies or used with
CancelPolicyGeneration to cancel the policy generation request.
"""
function cancel_policy_generation(jobId; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"PUT",
"/policy/generation/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_policy_generation(
jobId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/policy/generation/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
check_access_not_granted(access, policy_document, policy_type)
check_access_not_granted(access, policy_document, policy_type, params::Dict{String,<:Any})
Checks whether the specified access isn't allowed by a policy.
# Arguments
- `access`: An access object containing the permissions that shouldn't be granted by the
specified policy. If only actions are specified, IAM Access Analyzer checks for access of
the actions on all resources in the policy. If only resources are specified, then IAM
Access Analyzer checks which actions have access to the specified resources. If both
actions and resources are specified, then IAM Access Analyzer checks which of the specified
actions have access to the specified resources.
- `policy_document`: The JSON policy document to use as the content for the policy.
- `policy_type`: The type of policy. Identity policies grant permissions to IAM principals.
Identity policies include managed and inline policies for IAM roles, users, and groups.
Resource policies grant permissions on Amazon Web Services resources. Resource policies
include trust policies for IAM roles and bucket policies for Amazon S3 buckets. You can
provide a generic input such as identity policy or resource policy or a specific input such
as managed policy or Amazon S3 bucket policy.
"""
function check_access_not_granted(
access, policyDocument, policyType; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/policy/check-access-not-granted",
Dict{String,Any}(
"access" => access,
"policyDocument" => policyDocument,
"policyType" => policyType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function check_access_not_granted(
access,
policyDocument,
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/policy/check-access-not-granted",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"access" => access,
"policyDocument" => policyDocument,
"policyType" => policyType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
check_no_new_access(existing_policy_document, new_policy_document, policy_type)
check_no_new_access(existing_policy_document, new_policy_document, policy_type, params::Dict{String,<:Any})
Checks whether new access is allowed for an updated policy when compared to the existing
policy. You can find examples for reference policies and learn how to set up and run a
custom policy check for new access in the IAM Access Analyzer custom policy checks samples
repository on GitHub. The reference policies in this repository are meant to be passed to
the existingPolicyDocument request parameter.
# Arguments
- `existing_policy_document`: The JSON policy document to use as the content for the
existing policy.
- `new_policy_document`: The JSON policy document to use as the content for the updated
policy.
- `policy_type`: The type of policy to compare. Identity policies grant permissions to IAM
principals. Identity policies include managed and inline policies for IAM roles, users, and
groups. Resource policies grant permissions on Amazon Web Services resources. Resource
policies include trust policies for IAM roles and bucket policies for Amazon S3 buckets.
You can provide a generic input such as identity policy or resource policy or a specific
input such as managed policy or Amazon S3 bucket policy.
"""
function check_no_new_access(
existingPolicyDocument,
newPolicyDocument,
policyType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/policy/check-no-new-access",
Dict{String,Any}(
"existingPolicyDocument" => existingPolicyDocument,
"newPolicyDocument" => newPolicyDocument,
"policyType" => policyType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function check_no_new_access(
existingPolicyDocument,
newPolicyDocument,
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/policy/check-no-new-access",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"existingPolicyDocument" => existingPolicyDocument,
"newPolicyDocument" => newPolicyDocument,
"policyType" => policyType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
check_no_public_access(policy_document, resource_type)
check_no_public_access(policy_document, resource_type, params::Dict{String,<:Any})
Checks whether a resource policy can grant public access to the specified resource type.
# Arguments
- `policy_document`: The JSON policy document to evaluate for public access.
- `resource_type`: The type of resource to evaluate for public access. For example, to
check for public access to Amazon S3 buckets, you can choose AWS::S3::Bucket for the
resource type. For resource types not supported as valid values, IAM Access Analyzer will
return an error.
"""
function check_no_public_access(
policyDocument, resourceType; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/policy/check-no-public-access",
Dict{String,Any}(
"policyDocument" => policyDocument, "resourceType" => resourceType
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function check_no_public_access(
policyDocument,
resourceType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/policy/check-no-public-access",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"policyDocument" => policyDocument, "resourceType" => resourceType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_access_preview(analyzer_arn, configurations)
create_access_preview(analyzer_arn, configurations, params::Dict{String,<:Any})
Creates an access preview that allows you to preview IAM Access Analyzer findings for your
resource before deploying resource permissions.
# Arguments
- `analyzer_arn`: The ARN of the account analyzer used to generate the access preview. You
can only create an access preview for analyzers with an Account type and Active status.
- `configurations`: Access control configuration for your resource that is used to generate
the access preview. The access preview includes findings for external access allowed to the
resource with the proposed access control configuration. The configuration must contain
exactly one element.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function create_access_preview(
analyzerArn, configurations; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/access-preview",
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"configurations" => configurations,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_access_preview(
analyzerArn,
configurations,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/access-preview",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"configurations" => configurations,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_analyzer(analyzer_name, type)
create_analyzer(analyzer_name, type, params::Dict{String,<:Any})
Creates an analyzer for your account.
# Arguments
- `analyzer_name`: The name of the analyzer to create.
- `type`: The type of analyzer to create. Only ACCOUNT, ORGANIZATION,
ACCOUNT_UNUSED_ACCESS, and ORGANIZATION_UNUSED_ACCESS analyzers are supported. You can
create only one analyzer per account per Region. You can create up to 5 analyzers per
organization per Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"archiveRules"`: Specifies the archive rules to add for the analyzer. Archive rules
automatically archive findings that meet the criteria you define for the rule.
- `"clientToken"`: A client token.
- `"configuration"`: Specifies the configuration of the analyzer. If the analyzer is an
unused access analyzer, the specified scope of unused access is used for the configuration.
If the analyzer is an external access analyzer, this field is not used.
- `"tags"`: An array of key-value pairs to apply to the analyzer.
"""
function create_analyzer(
analyzerName, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/analyzer",
Dict{String,Any}(
"analyzerName" => analyzerName, "type" => type, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_analyzer(
analyzerName,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/analyzer",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerName" => analyzerName,
"type" => type,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_archive_rule(analyzer_name, filter, rule_name)
create_archive_rule(analyzer_name, filter, rule_name, params::Dict{String,<:Any})
Creates an archive rule for the specified analyzer. Archive rules automatically archive new
findings that meet the criteria you define when you create the rule. To learn about filter
keys that you can use to create an archive rule, see IAM Access Analyzer filter keys in the
IAM User Guide.
# Arguments
- `analyzer_name`: The name of the created analyzer.
- `filter`: The criteria for the rule.
- `rule_name`: The name of the rule to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function create_archive_rule(
analyzerName, filter, ruleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/analyzer/$(analyzerName)/archive-rule",
Dict{String,Any}(
"filter" => filter, "ruleName" => ruleName, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_archive_rule(
analyzerName,
filter,
ruleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/analyzer/$(analyzerName)/archive-rule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filter" => filter,
"ruleName" => ruleName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_analyzer(analyzer_name)
delete_analyzer(analyzer_name, params::Dict{String,<:Any})
Deletes the specified analyzer. When you delete an analyzer, IAM Access Analyzer is
disabled for the account or organization in the current or specific Region. All findings
that were generated by the analyzer are deleted. You cannot undo this action.
# Arguments
- `analyzer_name`: The name of the analyzer to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function delete_analyzer(analyzerName; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"DELETE",
"/analyzer/$(analyzerName)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_analyzer(
analyzerName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"DELETE",
"/analyzer/$(analyzerName)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_archive_rule(analyzer_name, rule_name)
delete_archive_rule(analyzer_name, rule_name, params::Dict{String,<:Any})
Deletes the specified archive rule.
# Arguments
- `analyzer_name`: The name of the analyzer that associated with the archive rule to delete.
- `rule_name`: The name of the rule to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function delete_archive_rule(
analyzerName, ruleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"DELETE",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_archive_rule(
analyzerName,
ruleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"DELETE",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
generate_finding_recommendation(analyzer_arn, id)
generate_finding_recommendation(analyzer_arn, id, params::Dict{String,<:Any})
Creates a recommendation for an unused permissions finding.
# Arguments
- `analyzer_arn`: The ARN of the analyzer used to generate the finding recommendation.
- `id`: The unique ID for the finding recommendation.
"""
function generate_finding_recommendation(
analyzerArn, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/recommendation/$(id)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function generate_finding_recommendation(
analyzerArn,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/recommendation/$(id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_access_preview(access_preview_id, analyzer_arn)
get_access_preview(access_preview_id, analyzer_arn, params::Dict{String,<:Any})
Retrieves information about an access preview for the specified analyzer.
# Arguments
- `access_preview_id`: The unique ID for the access preview.
- `analyzer_arn`: The ARN of the analyzer used to generate the access preview.
"""
function get_access_preview(
accessPreviewId, analyzerArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/access-preview/$(accessPreviewId)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_access_preview(
accessPreviewId,
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/access-preview/$(accessPreviewId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_analyzed_resource(analyzer_arn, resource_arn)
get_analyzed_resource(analyzer_arn, resource_arn, params::Dict{String,<:Any})
Retrieves information about a resource that was analyzed.
# Arguments
- `analyzer_arn`: The ARN of the analyzer to retrieve information from.
- `resource_arn`: The ARN of the resource to retrieve information about.
"""
function get_analyzed_resource(
analyzerArn, resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/analyzed-resource",
Dict{String,Any}("analyzerArn" => analyzerArn, "resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_analyzed_resource(
analyzerArn,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/analyzed-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerArn" => analyzerArn, "resourceArn" => resourceArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_analyzer(analyzer_name)
get_analyzer(analyzer_name, params::Dict{String,<:Any})
Retrieves information about the specified analyzer.
# Arguments
- `analyzer_name`: The name of the analyzer retrieved.
"""
function get_analyzer(analyzerName; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_analyzer(
analyzerName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_archive_rule(analyzer_name, rule_name)
get_archive_rule(analyzer_name, rule_name, params::Dict{String,<:Any})
Retrieves information about an archive rule. To learn about filter keys that you can use to
create an archive rule, see IAM Access Analyzer filter keys in the IAM User Guide.
# Arguments
- `analyzer_name`: The name of the analyzer to retrieve rules from.
- `rule_name`: The name of the rule to retrieve.
"""
function get_archive_rule(
analyzerName, ruleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_archive_rule(
analyzerName,
ruleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_finding(analyzer_arn, id)
get_finding(analyzer_arn, id, params::Dict{String,<:Any})
Retrieves information about the specified finding. GetFinding and GetFindingV2 both use
access-analyzer:GetFinding in the Action element of an IAM policy statement. You must have
permission to perform the access-analyzer:GetFinding action.
# Arguments
- `analyzer_arn`: The ARN of the analyzer that generated the finding.
- `id`: The ID of the finding to retrieve.
"""
function get_finding(analyzerArn, id; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET",
"/finding/$(id)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_finding(
analyzerArn,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/finding/$(id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_finding_recommendation(analyzer_arn, id)
get_finding_recommendation(analyzer_arn, id, params::Dict{String,<:Any})
Retrieves information about a finding recommendation for the specified analyzer.
# Arguments
- `analyzer_arn`: The ARN of the analyzer used to generate the finding recommendation.
- `id`: The unique ID for the finding recommendation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
"""
function get_finding_recommendation(
analyzerArn, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/recommendation/$(id)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_finding_recommendation(
analyzerArn,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/recommendation/$(id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_finding_v2(analyzer_arn, id)
get_finding_v2(analyzer_arn, id, params::Dict{String,<:Any})
Retrieves information about the specified finding. GetFinding and GetFindingV2 both use
access-analyzer:GetFinding in the Action element of an IAM policy statement. You must have
permission to perform the access-analyzer:GetFinding action.
# Arguments
- `analyzer_arn`: The ARN of the analyzer that generated the finding.
- `id`: The ID of the finding to retrieve.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
"""
function get_finding_v2(analyzerArn, id; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET",
"/findingv2/$(id)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_finding_v2(
analyzerArn,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/findingv2/$(id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_generated_policy(job_id)
get_generated_policy(job_id, params::Dict{String,<:Any})
Retrieves the policy that was generated using StartPolicyGeneration.
# Arguments
- `job_id`: The JobId that is returned by the StartPolicyGeneration operation. The JobId
can be used with GetGeneratedPolicy to retrieve the generated policies or used with
CancelPolicyGeneration to cancel the policy generation request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeResourcePlaceholders"`: The level of detail that you want to generate. You can
specify whether to generate policies with placeholders for resource ARNs for actions that
support resource level granularity in policies. For example, in the resource section of a
policy, you can receive a placeholder such as \"Resource\":\"arn:aws:s3:::{BucketName}\"
instead of \"*\".
- `"includeServiceLevelTemplate"`: The level of detail that you want to generate. You can
specify whether to generate service-level policies. IAM Access Analyzer uses
iam:servicelastaccessed to identify services that have been used recently to create this
service-level template.
"""
function get_generated_policy(jobId; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET",
"/policy/generation/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_generated_policy(
jobId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/policy/generation/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_access_preview_findings(access_preview_id, analyzer_arn)
list_access_preview_findings(access_preview_id, analyzer_arn, params::Dict{String,<:Any})
Retrieves a list of access preview findings generated by the specified access preview.
# Arguments
- `access_preview_id`: The unique ID for the access preview.
- `analyzer_arn`: The ARN of the analyzer used to generate the access.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: Criteria to filter the returned findings.
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
"""
function list_access_preview_findings(
accessPreviewId, analyzerArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/access-preview/$(accessPreviewId)",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_access_preview_findings(
accessPreviewId,
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/access-preview/$(accessPreviewId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_access_previews(analyzer_arn)
list_access_previews(analyzer_arn, params::Dict{String,<:Any})
Retrieves a list of access previews for the specified analyzer.
# Arguments
- `analyzer_arn`: The ARN of the analyzer used to generate the access preview.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
"""
function list_access_previews(
analyzerArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/access-preview",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_access_previews(
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/access-preview",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_analyzed_resources(analyzer_arn)
list_analyzed_resources(analyzer_arn, params::Dict{String,<:Any})
Retrieves a list of resources of the specified type that have been analyzed by the
specified external access analyzer. This action is not supported for unused access
analyzers.
# Arguments
- `analyzer_arn`: The ARN of the analyzer to retrieve a list of analyzed resources from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"resourceType"`: The type of resource.
"""
function list_analyzed_resources(
analyzerArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/analyzed-resource",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_analyzed_resources(
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/analyzed-resource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_analyzers()
list_analyzers(params::Dict{String,<:Any})
Retrieves a list of analyzers.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"type"`: The type of analyzer.
"""
function list_analyzers(; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET", "/analyzer"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_analyzers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET", "/analyzer", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_archive_rules(analyzer_name)
list_archive_rules(analyzer_name, params::Dict{String,<:Any})
Retrieves a list of archive rules created for the specified analyzer.
# Arguments
- `analyzer_name`: The name of the analyzer to retrieve rules from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the request.
- `"nextToken"`: A token used for pagination of results returned.
"""
function list_archive_rules(analyzerName; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)/archive-rule";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_archive_rules(
analyzerName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/analyzer/$(analyzerName)/archive-rule",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_findings(analyzer_arn)
list_findings(analyzer_arn, params::Dict{String,<:Any})
Retrieves a list of findings generated by the specified analyzer. ListFindings and
ListFindingsV2 both use access-analyzer:ListFindings in the Action element of an IAM policy
statement. You must have permission to perform the access-analyzer:ListFindings action. To
learn about filter keys that you can use to retrieve a list of findings, see IAM Access
Analyzer filter keys in the IAM User Guide.
# Arguments
- `analyzer_arn`: The ARN of the analyzer to retrieve findings from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A filter to match for the findings to return.
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"sort"`: The sort order for the findings returned.
"""
function list_findings(analyzerArn; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"POST",
"/finding",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_findings(
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/finding",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_findings_v2(analyzer_arn)
list_findings_v2(analyzer_arn, params::Dict{String,<:Any})
Retrieves a list of findings generated by the specified analyzer. ListFindings and
ListFindingsV2 both use access-analyzer:ListFindings in the Action element of an IAM policy
statement. You must have permission to perform the access-analyzer:ListFindings action. To
learn about filter keys that you can use to retrieve a list of findings, see IAM Access
Analyzer filter keys in the IAM User Guide.
# Arguments
- `analyzer_arn`: The ARN of the analyzer to retrieve findings from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A filter to match for the findings to return.
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"sort"`:
"""
function list_findings_v2(analyzerArn; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"POST",
"/findingv2",
Dict{String,Any}("analyzerArn" => analyzerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_findings_v2(
analyzerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/findingv2",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("analyzerArn" => analyzerArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_policy_generations()
list_policy_generations(params::Dict{String,<:Any})
Lists all of the policy generations requested in the last seven days.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"principalArn"`: The ARN of the IAM entity (user or role) for which you are generating a
policy. Use this with ListGeneratedPolicies to filter the results to only include results
for a specific principal.
"""
function list_policy_generations(; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"GET", "/policy/generation"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_policy_generations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/policy/generation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieves a list of tags applied to the specified resource.
# Arguments
- `resource_arn`: The ARN of the resource to retrieve tags from.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_policy_generation(policy_generation_details)
start_policy_generation(policy_generation_details, params::Dict{String,<:Any})
Starts the policy generation request.
# Arguments
- `policy_generation_details`: Contains the ARN of the IAM entity (user or role) for which
you are generating a policy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Idempotency ensures that an API request completes only once.
With an idempotent request, if the original request completes successfully, the subsequent
retries with the same client token return the result from the original successful request
and they have no additional effect. If you do not specify a client token, one is
automatically generated by the Amazon Web Services SDK.
- `"cloudTrailDetails"`: A CloudTrailDetails object that contains details about a Trail
that you want to analyze to generate policies.
"""
function start_policy_generation(
policyGenerationDetails; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/policy/generation",
Dict{String,Any}(
"policyGenerationDetails" => policyGenerationDetails,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_policy_generation(
policyGenerationDetails,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/policy/generation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"policyGenerationDetails" => policyGenerationDetails,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_resource_scan(analyzer_arn, resource_arn)
start_resource_scan(analyzer_arn, resource_arn, params::Dict{String,<:Any})
Immediately starts a scan of the policies applied to the specified resource.
# Arguments
- `analyzer_arn`: The ARN of the analyzer to use to scan the policies applied to the
specified resource.
- `resource_arn`: The ARN of the resource to scan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceOwnerAccount"`: The Amazon Web Services account ID that owns the resource. For
most Amazon Web Services resources, the owning account is the account in which the resource
was created.
"""
function start_resource_scan(
analyzerArn, resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/resource/scan",
Dict{String,Any}("analyzerArn" => analyzerArn, "resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_resource_scan(
analyzerArn,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/resource/scan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerArn" => analyzerArn, "resourceArn" => resourceArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds a tag to the specified resource.
# Arguments
- `resource_arn`: The ARN of the resource to add the tag to.
- `tags`: The tags to add to the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return accessanalyzer(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag from the specified resource.
# Arguments
- `resource_arn`: The ARN of the resource to remove the tag from.
- `tag_keys`: The key for the tag to add.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_archive_rule(analyzer_name, filter, rule_name)
update_archive_rule(analyzer_name, filter, rule_name, params::Dict{String,<:Any})
Updates the criteria and values for the specified archive rule.
# Arguments
- `analyzer_name`: The name of the analyzer to update the archive rules for.
- `filter`: A filter to match for the rules to update. Only rules that match the filter are
updated.
- `rule_name`: The name of the rule to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
"""
function update_archive_rule(
analyzerName, filter, ruleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)",
Dict{String,Any}("filter" => filter, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_archive_rule(
analyzerName,
filter,
ruleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/analyzer/$(analyzerName)/archive-rule/$(ruleName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("filter" => filter, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_findings(analyzer_arn, status)
update_findings(analyzer_arn, status, params::Dict{String,<:Any})
Updates the status for the specified findings.
# Arguments
- `analyzer_arn`: The ARN of the analyzer that generated the findings to update.
- `status`: The state represents the action to take to update the finding Status. Use
ARCHIVE to change an Active finding to an Archived finding. Use ACTIVE to change an
Archived finding to an Active finding.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A client token.
- `"ids"`: The IDs of the findings to update.
- `"resourceArn"`: The ARN of the resource identified in the finding.
"""
function update_findings(
analyzerArn, status; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"PUT",
"/finding",
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"status" => status,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_findings(
analyzerArn,
status,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"PUT",
"/finding",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analyzerArn" => analyzerArn,
"status" => status,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
validate_policy(policy_document, policy_type)
validate_policy(policy_document, policy_type, params::Dict{String,<:Any})
Requests the validation of a policy and returns a list of findings. The findings help you
identify issues and provide actionable recommendations to resolve the issue and enable you
to author functional policies that meet security best practices.
# Arguments
- `policy_document`: The JSON policy document to use as the content for the policy.
- `policy_type`: The type of policy to validate. Identity policies grant permissions to IAM
principals. Identity policies include managed and inline policies for IAM roles, users, and
groups. Resource policies grant permissions on Amazon Web Services resources. Resource
policies include trust policies for IAM roles and bucket policies for Amazon S3 buckets.
You can provide a generic input such as identity policy or resource policy or a specific
input such as managed policy or Amazon S3 bucket policy. Service control policies (SCPs)
are a type of organization policy attached to an Amazon Web Services organization,
organizational unit (OU), or an account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"locale"`: The locale to use for localizing the findings.
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned.
- `"validatePolicyResourceType"`: The type of resource to attach to your resource policy.
Specify a value for the policy validation resource type only if the policy type is
RESOURCE_POLICY. For example, to validate a resource policy to attach to an Amazon S3
bucket, you can choose AWS::S3::Bucket for the policy validation resource type. For
resource types not supported as valid values, IAM Access Analyzer runs policy checks that
apply to all resource policies. For example, to validate a resource policy to attach to a
KMS key, do not specify a value for the policy validation resource type and IAM Access
Analyzer will run policy checks that apply to all resource policies.
"""
function validate_policy(
policyDocument, policyType; aws_config::AbstractAWSConfig=global_aws_config()
)
return accessanalyzer(
"POST",
"/policy/validation",
Dict{String,Any}("policyDocument" => policyDocument, "policyType" => policyType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function validate_policy(
policyDocument,
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return accessanalyzer(
"POST",
"/policy/validation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"policyDocument" => policyDocument, "policyType" => policyType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 30049 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: account
using AWS.Compat
using AWS.UUIDs
"""
accept_primary_email_update(account_id, otp, primary_email)
accept_primary_email_update(account_id, otp, primary_email, params::Dict{String,<:Any})
Accepts the request that originated from StartPrimaryEmailUpdate to update the primary
email address (also known as the root user email address) for the specified account.
# Arguments
- `account_id`: Specifies the 12-digit account ID number of the Amazon Web Services account
that you want to access or modify with this operation. To use this parameter, the caller
must be an identity in the organization's management account or a delegated administrator
account. The specified account ID must be a member account in the same organization. The
organization must have all features enabled, and the organization must have trusted access
enabled for the Account Management service, and optionally a delegated admin account
assigned. This operation can only be called from the management account or the delegated
administrator account of an organization for a member account. The management account
can't specify its own AccountId.
- `otp`: The OTP code sent to the PrimaryEmail specified on the StartPrimaryEmailUpdate API
call.
- `primary_email`: The new primary email address for use with the specified account. This
must match the PrimaryEmail from the StartPrimaryEmailUpdate API call.
"""
function accept_primary_email_update(
AccountId, Otp, PrimaryEmail; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/acceptPrimaryEmailUpdate",
Dict{String,Any}(
"AccountId" => AccountId, "Otp" => Otp, "PrimaryEmail" => PrimaryEmail
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function accept_primary_email_update(
AccountId,
Otp,
PrimaryEmail,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/acceptPrimaryEmailUpdate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId, "Otp" => Otp, "PrimaryEmail" => PrimaryEmail
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_alternate_contact(alternate_contact_type)
delete_alternate_contact(alternate_contact_type, params::Dict{String,<:Any})
Deletes the specified alternate contact from an Amazon Web Services account. For complete
details about how to use the alternate contact operations, see Access or updating the
alternate contacts. Before you can update the alternate contact information for an Amazon
Web Services account that is managed by Organizations, you must first enable integration
between Amazon Web Services Account Management and Organizations. For more information, see
Enabling trusted access for Amazon Web Services Account Management.
# Arguments
- `alternate_contact_type`: Specifies which of the alternate contacts to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12 digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you do not specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account, and the specified account ID must
be a member account in the same organization. The organization must have all features
enabled, and the organization must have trusted access enabled for the Account Management
service, and optionally a delegated admin account assigned. The management account can't
specify its own AccountId; it must call the operation in standalone context by not
including the AccountId parameter. To call this operation on an account that is not a
member of an organization, then don't specify this parameter, and call the operation using
an identity belonging to the account whose contacts you wish to retrieve or modify.
"""
function delete_alternate_contact(
AlternateContactType; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/deleteAlternateContact",
Dict{String,Any}("AlternateContactType" => AlternateContactType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_alternate_contact(
AlternateContactType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/deleteAlternateContact",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AlternateContactType" => AlternateContactType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_region(region_name)
disable_region(region_name, params::Dict{String,<:Any})
Disables (opts-out) a particular Region for an account. The act of disabling a Region will
remove all IAM access to any resources that reside in that Region.
# Arguments
- `region_name`: Specifies the Region-code for a given Region name (for example,
af-south-1). When you disable a Region, Amazon Web Services performs actions to deactivate
that Region in your account, such as destroying IAM resources in the Region. This process
takes a few minutes for most accounts, but this can take several hours. You cannot enable
the Region until the disabling process is fully completed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
"""
function disable_region(RegionName; aws_config::AbstractAWSConfig=global_aws_config())
return account(
"POST",
"/disableRegion",
Dict{String,Any}("RegionName" => RegionName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_region(
RegionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/disableRegion",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RegionName" => RegionName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_region(region_name)
enable_region(region_name, params::Dict{String,<:Any})
Enables (opts-in) a particular Region for an account.
# Arguments
- `region_name`: Specifies the Region-code for a given Region name (for example,
af-south-1). When you enable a Region, Amazon Web Services performs actions to prepare your
account in that Region, such as distributing your IAM resources to the Region. This process
takes a few minutes for most accounts, but it can take several hours. You cannot use the
Region until this process is complete. Furthermore, you cannot disable the Region until the
enabling process is fully completed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
"""
function enable_region(RegionName; aws_config::AbstractAWSConfig=global_aws_config())
return account(
"POST",
"/enableRegion",
Dict{String,Any}("RegionName" => RegionName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_region(
RegionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/enableRegion",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RegionName" => RegionName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_alternate_contact(alternate_contact_type)
get_alternate_contact(alternate_contact_type, params::Dict{String,<:Any})
Retrieves the specified alternate contact attached to an Amazon Web Services account. For
complete details about how to use the alternate contact operations, see Access or updating
the alternate contacts. Before you can update the alternate contact information for an
Amazon Web Services account that is managed by Organizations, you must first enable
integration between Amazon Web Services Account Management and Organizations. For more
information, see Enabling trusted access for Amazon Web Services Account Management.
# Arguments
- `alternate_contact_type`: Specifies which alternate contact you want to retrieve.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12 digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you do not specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account, and the specified account ID must
be a member account in the same organization. The organization must have all features
enabled, and the organization must have trusted access enabled for the Account Management
service, and optionally a delegated admin account assigned. The management account can't
specify its own AccountId; it must call the operation in standalone context by not
including the AccountId parameter. To call this operation on an account that is not a
member of an organization, then don't specify this parameter, and call the operation using
an identity belonging to the account whose contacts you wish to retrieve or modify.
"""
function get_alternate_contact(
AlternateContactType; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/getAlternateContact",
Dict{String,Any}("AlternateContactType" => AlternateContactType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_alternate_contact(
AlternateContactType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/getAlternateContact",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AlternateContactType" => AlternateContactType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_contact_information()
get_contact_information(params::Dict{String,<:Any})
Retrieves the primary contact information of an Amazon Web Services account. For complete
details about how to use the primary contact operations, see Update the primary and
alternate contact information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
"""
function get_contact_information(; aws_config::AbstractAWSConfig=global_aws_config())
return account(
"POST",
"/getContactInformation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_contact_information(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/getContactInformation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_primary_email(account_id)
get_primary_email(account_id, params::Dict{String,<:Any})
Retrieves the primary email address for the specified account.
# Arguments
- `account_id`: Specifies the 12-digit account ID number of the Amazon Web Services account
that you want to access or modify with this operation. To use this parameter, the caller
must be an identity in the organization's management account or a delegated administrator
account. The specified account ID must be a member account in the same organization. The
organization must have all features enabled, and the organization must have trusted access
enabled for the Account Management service, and optionally a delegated admin account
assigned. This operation can only be called from the management account or the delegated
administrator account of an organization for a member account. The management account
can't specify its own AccountId.
"""
function get_primary_email(AccountId; aws_config::AbstractAWSConfig=global_aws_config())
return account(
"POST",
"/getPrimaryEmail",
Dict{String,Any}("AccountId" => AccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_primary_email(
AccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/getPrimaryEmail",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AccountId" => AccountId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_region_opt_status(region_name)
get_region_opt_status(region_name, params::Dict{String,<:Any})
Retrieves the opt-in status of a particular Region.
# Arguments
- `region_name`: Specifies the Region-code for a given Region name (for example,
af-south-1). This function will return the status of whatever Region you pass into this
parameter.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
"""
function get_region_opt_status(
RegionName; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/getRegionOptStatus",
Dict{String,Any}("RegionName" => RegionName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_region_opt_status(
RegionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/getRegionOptStatus",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RegionName" => RegionName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_regions()
list_regions(params::Dict{String,<:Any})
Lists all the Regions for a given account and their respective opt-in statuses. Optionally,
this list can be filtered by the region-opt-status-contains parameter.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
- `"MaxResults"`: The total number of items to return in the command’s output. If the
total number of items available is more than the value specified, a NextToken is provided
in the command’s output. To resume pagination, provide the NextToken value in the
starting-token argument of a subsequent command. Do not use the NextToken response element
directly outside of the Amazon Web Services CLI. For usage examples, see Pagination in the
Amazon Web Services Command Line Interface User Guide.
- `"NextToken"`: A token used to specify where to start paginating. This is the NextToken
from a previously truncated response. For usage examples, see Pagination in the Amazon Web
Services Command Line Interface User Guide.
- `"RegionOptStatusContains"`: A list of Region statuses (Enabling, Enabled, Disabling,
Disabled, Enabled_by_default) to use to filter the list of Regions for a given account. For
example, passing in a value of ENABLING will only return a list of Regions with a Region
status of ENABLING.
"""
function list_regions(; aws_config::AbstractAWSConfig=global_aws_config())
return account(
"POST", "/listRegions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_regions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/listRegions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_alternate_contact(alternate_contact_type, email_address, name, phone_number, title)
put_alternate_contact(alternate_contact_type, email_address, name, phone_number, title, params::Dict{String,<:Any})
Modifies the specified alternate contact attached to an Amazon Web Services account. For
complete details about how to use the alternate contact operations, see Access or updating
the alternate contacts. Before you can update the alternate contact information for an
Amazon Web Services account that is managed by Organizations, you must first enable
integration between Amazon Web Services Account Management and Organizations. For more
information, see Enabling trusted access for Amazon Web Services Account Management.
# Arguments
- `alternate_contact_type`: Specifies which alternate contact you want to create or update.
- `email_address`: Specifies an email address for the alternate contact.
- `name`: Specifies a name for the alternate contact.
- `phone_number`: Specifies a phone number for the alternate contact.
- `title`: Specifies a title for the alternate contact.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12 digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you do not specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account, and the specified account ID must
be a member account in the same organization. The organization must have all features
enabled, and the organization must have trusted access enabled for the Account Management
service, and optionally a delegated admin account assigned. The management account can't
specify its own AccountId; it must call the operation in standalone context by not
including the AccountId parameter. To call this operation on an account that is not a
member of an organization, then don't specify this parameter, and call the operation using
an identity belonging to the account whose contacts you wish to retrieve or modify.
"""
function put_alternate_contact(
AlternateContactType,
EmailAddress,
Name,
PhoneNumber,
Title;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/putAlternateContact",
Dict{String,Any}(
"AlternateContactType" => AlternateContactType,
"EmailAddress" => EmailAddress,
"Name" => Name,
"PhoneNumber" => PhoneNumber,
"Title" => Title,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_alternate_contact(
AlternateContactType,
EmailAddress,
Name,
PhoneNumber,
Title,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/putAlternateContact",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AlternateContactType" => AlternateContactType,
"EmailAddress" => EmailAddress,
"Name" => Name,
"PhoneNumber" => PhoneNumber,
"Title" => Title,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_contact_information(contact_information)
put_contact_information(contact_information, params::Dict{String,<:Any})
Updates the primary contact information of an Amazon Web Services account. For complete
details about how to use the primary contact operations, see Update the primary and
alternate contact information.
# Arguments
- `contact_information`: Contains the details of the primary contact information associated
with an Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Specifies the 12-digit account ID number of the Amazon Web Services
account that you want to access or modify with this operation. If you don't specify this
parameter, it defaults to the Amazon Web Services account of the identity used to call the
operation. To use this parameter, the caller must be an identity in the organization's
management account or a delegated administrator account. The specified account ID must be a
member account in the same organization. The organization must have all features enabled,
and the organization must have trusted access enabled for the Account Management service,
and optionally a delegated admin account assigned. The management account can't specify
its own AccountId. It must call the operation in standalone context by not including the
AccountId parameter. To call this operation on an account that is not a member of an
organization, don't specify this parameter. Instead, call the operation using an identity
belonging to the account whose contacts you wish to retrieve or modify.
"""
function put_contact_information(
ContactInformation; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/putContactInformation",
Dict{String,Any}("ContactInformation" => ContactInformation);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_contact_information(
ContactInformation,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/putContactInformation",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ContactInformation" => ContactInformation), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_primary_email_update(account_id, primary_email)
start_primary_email_update(account_id, primary_email, params::Dict{String,<:Any})
Starts the process to update the primary email address for the specified account.
# Arguments
- `account_id`: Specifies the 12-digit account ID number of the Amazon Web Services account
that you want to access or modify with this operation. To use this parameter, the caller
must be an identity in the organization's management account or a delegated administrator
account. The specified account ID must be a member account in the same organization. The
organization must have all features enabled, and the organization must have trusted access
enabled for the Account Management service, and optionally a delegated admin account
assigned. This operation can only be called from the management account or the delegated
administrator account of an organization for a member account. The management account
can't specify its own AccountId.
- `primary_email`: The new primary email address (also known as the root user email
address) to use in the specified account.
"""
function start_primary_email_update(
AccountId, PrimaryEmail; aws_config::AbstractAWSConfig=global_aws_config()
)
return account(
"POST",
"/startPrimaryEmailUpdate",
Dict{String,Any}("AccountId" => AccountId, "PrimaryEmail" => PrimaryEmail);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_primary_email_update(
AccountId,
PrimaryEmail,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return account(
"POST",
"/startPrimaryEmailUpdate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "PrimaryEmail" => PrimaryEmail),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 33258 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: acm
using AWS.Compat
using AWS.UUIDs
"""
add_tags_to_certificate(certificate_arn, tags)
add_tags_to_certificate(certificate_arn, tags, params::Dict{String,<:Any})
Adds one or more tags to an ACM certificate. Tags are labels that you can use to identify
and organize your Amazon Web Services resources. Each tag consists of a key and an optional
value. You specify the certificate on input by its Amazon Resource Name (ARN). You specify
the tag by using a key-value pair. You can apply a tag to just one certificate if you want
to identify a specific characteristic of that certificate, or you can apply the same tag to
multiple certificates if you want to filter for a common relationship among those
certificates. Similarly, you can apply the same tag to multiple resources if you want to
specify a relationship among those resources. For example, you can add the same tag to an
ACM certificate and an Elastic Load Balancing load balancer to indicate that they are both
used by the same website. For more information, see Tagging ACM certificates. To remove
one or more tags, use the RemoveTagsFromCertificate action. To view all of the tags that
have been applied to the certificate, use the ListTagsForCertificate action.
# Arguments
- `certificate_arn`: String that contains the ARN of the ACM certificate to which the tag
is to be applied. This must be of the form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
- `tags`: The key-value pair that defines the tag. The tag value is optional.
"""
function add_tags_to_certificate(
CertificateArn, Tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"AddTagsToCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_tags_to_certificate(
CertificateArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"AddTagsToCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateArn" => CertificateArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_certificate(certificate_arn)
delete_certificate(certificate_arn, params::Dict{String,<:Any})
Deletes a certificate and its associated private key. If this action succeeds, the
certificate no longer appears in the list that can be displayed by calling the
ListCertificates action or be retrieved by calling the GetCertificate action. The
certificate will not be available for use by Amazon Web Services services integrated with
ACM. You cannot delete an ACM certificate that is being used by another Amazon Web
Services service. To delete a certificate that is in use, the certificate association must
first be removed.
# Arguments
- `certificate_arn`: String that contains the ARN of the ACM certificate to be deleted.
This must be of the form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
"""
function delete_certificate(
CertificateArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"DeleteCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_certificate(
CertificateArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"DeleteCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CertificateArn" => CertificateArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_certificate(certificate_arn)
describe_certificate(certificate_arn, params::Dict{String,<:Any})
Returns detailed metadata about the specified ACM certificate. If you have just created a
certificate using the RequestCertificate action, there is a delay of several seconds before
you can retrieve information about it.
# Arguments
- `certificate_arn`: The Amazon Resource Name (ARN) of the ACM certificate. The ARN must
have the following form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
"""
function describe_certificate(
CertificateArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"DescribeCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_certificate(
CertificateArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"DescribeCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CertificateArn" => CertificateArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_certificate(certificate_arn, passphrase)
export_certificate(certificate_arn, passphrase, params::Dict{String,<:Any})
Exports a private certificate issued by a private certificate authority (CA) for use
anywhere. The exported file contains the certificate, the certificate chain, and the
encrypted private 2048-bit RSA key associated with the public key that is embedded in the
certificate. For security, you must assign a passphrase for the private key when exporting
it. For information about exporting and formatting a certificate using the ACM console or
CLI, see Export a Private Certificate.
# Arguments
- `certificate_arn`: An Amazon Resource Name (ARN) of the issued certificate. This must be
of the form: arn:aws:acm:region:account:certificate/12345678-1234-1234-1234-123456789012
- `passphrase`: Passphrase to associate with the encrypted exported private key. When
creating your passphrase, you can use any ASCII character except #, , or %. If you want to
later decrypt the private key, you must have the passphrase. You can use the following
OpenSSL command to decrypt a private key. After entering the command, you are prompted for
the passphrase. openssl rsa -in encrypted_key.pem -out decrypted_key.pem
"""
function export_certificate(
CertificateArn, Passphrase; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"ExportCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn, "Passphrase" => Passphrase);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_certificate(
CertificateArn,
Passphrase,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"ExportCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateArn" => CertificateArn, "Passphrase" => Passphrase
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account_configuration()
get_account_configuration(params::Dict{String,<:Any})
Returns the account configuration options associated with an Amazon Web Services account.
"""
function get_account_configuration(; aws_config::AbstractAWSConfig=global_aws_config())
return acm(
"GetAccountConfiguration"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_account_configuration(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"GetAccountConfiguration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_certificate(certificate_arn)
get_certificate(certificate_arn, params::Dict{String,<:Any})
Retrieves an Amazon-issued certificate and its certificate chain. The chain consists of the
certificate of the issuing CA and the intermediate certificates of any other subordinate
CAs. All of the certificates are base64 encoded. You can use OpenSSL to decode the
certificates and inspect individual fields.
# Arguments
- `certificate_arn`: String that contains a certificate ARN in the following format:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
"""
function get_certificate(CertificateArn; aws_config::AbstractAWSConfig=global_aws_config())
return acm(
"GetCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_certificate(
CertificateArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"GetCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CertificateArn" => CertificateArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_certificate(certificate, private_key)
import_certificate(certificate, private_key, params::Dict{String,<:Any})
Imports a certificate into Certificate Manager (ACM) to use with services that are
integrated with ACM. Note that integrated services allow only certificate types and keys
they support to be associated with their resources. Further, their support differs
depending on whether the certificate is imported into IAM or into ACM. For more
information, see the documentation for each service. For more information about importing
certificates into ACM, see Importing Certificates in the Certificate Manager User Guide.
ACM does not provide managed renewal for certificates that you import. Note the following
guidelines when importing third party certificates: You must enter the private key that
matches the certificate you are importing. The private key must be unencrypted. You
cannot import a private key that is protected by a password or a passphrase. The private
key must be no larger than 5 KB (5,120 bytes). If the certificate you are importing is
not self-signed, you must enter its certificate chain. If a certificate chain is
included, the issuer must be the subject of one of the certificates in the chain. The
certificate, private key, and certificate chain must be PEM-encoded. The current time
must be between the Not Before and Not After certificate fields. The Issuer field must
not be empty. The OCSP authority URL, if present, must not exceed 1000 characters. To
import a new certificate, omit the CertificateArn argument. Include this argument only when
you want to replace a previously imported certificate. When you import a certificate by
using the CLI, you must specify the certificate, the certificate chain, and the private key
by their file names preceded by fileb://. For example, you can specify a certificate saved
in the C:temp folder as fileb://C:tempcertificate_to_import.pem. If you are making an HTTP
or HTTPS Query request, include these arguments as BLOBs. When you import a certificate
by using an SDK, you must specify the certificate, the certificate chain, and the private
key files in the manner required by the programming language you're using. The
cryptographic algorithm of an imported certificate must match the algorithm of the signing
CA. For example, if the signing CA key type is RSA, then the certificate key type must also
be RSA. This operation returns the Amazon Resource Name (ARN) of the imported certificate.
# Arguments
- `certificate`: The certificate to import.
- `private_key`: The private key that matches the public key in the certificate.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateArn"`: The Amazon Resource Name (ARN) of an imported certificate to replace.
To import a new certificate, omit this field.
- `"CertificateChain"`: The PEM encoded certificate chain.
- `"Tags"`: One or more resource tags to associate with the imported certificate. Note:
You cannot apply tags when reimporting a certificate.
"""
function import_certificate(
Certificate, PrivateKey; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"ImportCertificate",
Dict{String,Any}("Certificate" => Certificate, "PrivateKey" => PrivateKey);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_certificate(
Certificate,
PrivateKey,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"ImportCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Certificate" => Certificate, "PrivateKey" => PrivateKey),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_certificates()
list_certificates(params::Dict{String,<:Any})
Retrieves a list of certificate ARNs and domain names. You can request that only
certificates that match a specific status be listed. You can also filter by specific
attributes of the certificate. Default filtering returns only RSA_2048 certificates. For
more information, see Filters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateStatuses"`: Filter the certificate list by status value.
- `"Includes"`: Filter the certificate list. For more information, see the Filters
structure.
- `"MaxItems"`: Use this parameter when paginating results to specify the maximum number of
items to return in the response. If additional items exist beyond the number you specify,
the NextToken element is sent in the response. Use this NextToken value in a subsequent
request to retrieve additional items.
- `"NextToken"`: Use this parameter only when paginating results and only in a subsequent
request after you receive a response with truncated results. Set it to the value of
NextToken from the response you just received.
- `"SortBy"`: Specifies the field to sort results by. If you specify SortBy, you must also
specify SortOrder.
- `"SortOrder"`: Specifies the order of sorted results. If you specify SortOrder, you must
also specify SortBy.
"""
function list_certificates(; aws_config::AbstractAWSConfig=global_aws_config())
return acm("ListCertificates"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_certificates(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"ListCertificates", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_certificate(certificate_arn)
list_tags_for_certificate(certificate_arn, params::Dict{String,<:Any})
Lists the tags that have been applied to the ACM certificate. Use the certificate's Amazon
Resource Name (ARN) to specify the certificate. To add a tag to an ACM certificate, use the
AddTagsToCertificate action. To delete a tag, use the RemoveTagsFromCertificate action.
# Arguments
- `certificate_arn`: String that contains the ARN of the ACM certificate for which you want
to list the tags. This must have the following form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
"""
function list_tags_for_certificate(
CertificateArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"ListTagsForCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_certificate(
CertificateArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"ListTagsForCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CertificateArn" => CertificateArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_account_configuration(idempotency_token)
put_account_configuration(idempotency_token, params::Dict{String,<:Any})
Adds or modifies account-level configurations in ACM. The supported configuration option
is DaysBeforeExpiry. This option specifies the number of days prior to certificate
expiration when ACM starts generating EventBridge events. ACM sends one event per day per
certificate until the certificate expires. By default, accounts receive events starting 45
days before certificate expiration.
# Arguments
- `idempotency_token`: Customer-chosen string used to distinguish between calls to
PutAccountConfiguration. Idempotency tokens time out after one hour. If you call
PutAccountConfiguration multiple times with the same unexpired idempotency token, ACM
treats it as the same request and returns the original result. If you change the
idempotency token for each call, ACM treats each call as a new request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpiryEvents"`: Specifies expiration events associated with an account.
"""
function put_account_configuration(
IdempotencyToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"PutAccountConfiguration",
Dict{String,Any}("IdempotencyToken" => IdempotencyToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_account_configuration(
IdempotencyToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"PutAccountConfiguration",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("IdempotencyToken" => IdempotencyToken), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_tags_from_certificate(certificate_arn, tags)
remove_tags_from_certificate(certificate_arn, tags, params::Dict{String,<:Any})
Remove one or more tags from an ACM certificate. A tag consists of a key-value pair. If you
do not specify the value portion of the tag when calling this function, the tag will be
removed regardless of value. If you specify a value, the tag is removed only if it is
associated with the specified value. To add tags to a certificate, use the
AddTagsToCertificate action. To view all of the tags that have been applied to a specific
ACM certificate, use the ListTagsForCertificate action.
# Arguments
- `certificate_arn`: String that contains the ARN of the ACM Certificate with one or more
tags that you want to remove. This must be of the form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
- `tags`: The key-value pair that defines the tag to remove.
"""
function remove_tags_from_certificate(
CertificateArn, Tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"RemoveTagsFromCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_tags_from_certificate(
CertificateArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"RemoveTagsFromCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateArn" => CertificateArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
renew_certificate(certificate_arn)
renew_certificate(certificate_arn, params::Dict{String,<:Any})
Renews an eligible ACM certificate. At this time, only exported private certificates can be
renewed with this operation. In order to renew your Amazon Web Services Private CA
certificates with ACM, you must first grant the ACM service principal permission to do so.
For more information, see Testing Managed Renewal in the ACM User Guide.
# Arguments
- `certificate_arn`: String that contains the ARN of the ACM certificate to be renewed.
This must be of the form:
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012 For more
information about ARNs, see Amazon Resource Names (ARNs).
"""
function renew_certificate(
CertificateArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"RenewCertificate",
Dict{String,Any}("CertificateArn" => CertificateArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function renew_certificate(
CertificateArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"RenewCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CertificateArn" => CertificateArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
request_certificate(domain_name)
request_certificate(domain_name, params::Dict{String,<:Any})
Requests an ACM certificate for use with other Amazon Web Services services. To request an
ACM certificate, you must specify a fully qualified domain name (FQDN) in the DomainName
parameter. You can also specify additional FQDNs in the SubjectAlternativeNames parameter.
If you are requesting a private certificate, domain validation is not required. If you are
requesting a public certificate, each domain name that you specify must be validated to
verify that you own or control the domain. You can use DNS validation or email validation.
We recommend that you use DNS validation. ACM issues public certificates after receiving
approval from the domain owner. ACM behavior differs from the RFC 6125 specification of
the certificate validation process. ACM first checks for a Subject Alternative Name, and,
if it finds one, ignores the common name (CN). After successful completion of the
RequestCertificate action, there is a delay of several seconds before you can retrieve
information about the new certificate.
# Arguments
- `domain_name`: Fully qualified domain name (FQDN), such as www.example.com, that you want
to secure with an ACM certificate. Use an asterisk (*) to create a wildcard certificate
that protects several sites in the same domain. For example, *.example.com protects
www.example.com, site.example.com, and images.example.com. In compliance with RFC 5280,
the length of the domain name (technically, the Common Name) that you provide cannot exceed
64 octets (characters), including periods. To add a longer domain name, specify it in the
Subject Alternative Name field, which supports names up to 253 octets in length.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateAuthorityArn"`: The Amazon Resource Name (ARN) of the private certificate
authority (CA) that will be used to issue the certificate. If you do not provide an ARN and
you are trying to request a private certificate, ACM will attempt to issue a public
certificate. For more information about private CAs, see the Amazon Web Services Private
Certificate Authority user guide. The ARN must have the following form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
- `"DomainValidationOptions"`: The domain name that you want ACM to use to send you emails
so that you can validate domain ownership.
- `"IdempotencyToken"`: Customer chosen string that can be used to distinguish between
calls to RequestCertificate. Idempotency tokens time out after one hour. Therefore, if you
call RequestCertificate multiple times with the same idempotency token within one hour, ACM
recognizes that you are requesting only one certificate and will issue only one. If you
change the idempotency token for each call, ACM recognizes that you are requesting multiple
certificates.
- `"KeyAlgorithm"`: Specifies the algorithm of the public and private key pair that your
certificate uses to encrypt data. RSA is the default key algorithm for ACM certificates.
Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller, offering security
comparable to RSA keys but with greater computing efficiency. However, ECDSA is not
supported by all network clients. Some AWS services may require RSA keys, or only support
ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to
ensure that compatibility is not broken. Check the requirements for the AWS service where
you plan to deploy your certificate. Default: RSA_2048
- `"Options"`: Currently, you can use this parameter to specify whether to add the
certificate to a certificate transparency log. Certificate transparency makes it possible
to detect SSL/TLS certificates that have been mistakenly or maliciously issued.
Certificates that have not been logged typically produce an error message in a browser. For
more information, see Opting Out of Certificate Transparency Logging.
- `"SubjectAlternativeNames"`: Additional FQDNs to be included in the Subject Alternative
Name extension of the ACM certificate. For example, add the name www.example.net to a
certificate for which the DomainName field is www.example.com if users can reach your site
by using either name. The maximum number of domain names that you can add to an ACM
certificate is 100. However, the initial quota is 10 domain names. If you need more than 10
names, you must request a quota increase. For more information, see Quotas. The maximum
length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by
periods. No label can be longer than 63 octets. Consider the following examples: (63
octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
(63+1+63+1+63+1+61) and no label exceeds 63 octets. (64 octets).(63 octets).(63
octets).(61 octets) is not legal because the total length exceeds 253 octets
(64+1+63+1+63+1+61) and the first label exceeds 63 octets. (63 octets).(63 octets).(63
octets).(62 octets) is not legal because the total length of the DNS name
(63+1+63+1+63+1+62) exceeds 253 octets.
- `"Tags"`: One or more resource tags to associate with the certificate.
- `"ValidationMethod"`: The method you want to use if you are requesting a public
certificate to validate that you own or control domain. You can validate with DNS or
validate with email. We recommend that you use DNS validation.
"""
function request_certificate(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return acm(
"RequestCertificate",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function request_certificate(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"RequestCertificate",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
resend_validation_email(certificate_arn, domain, validation_domain)
resend_validation_email(certificate_arn, domain, validation_domain, params::Dict{String,<:Any})
Resends the email that requests domain ownership validation. The domain owner or an
authorized representative must approve the ACM certificate before it can be issued. The
certificate can be approved by clicking a link in the mail to navigate to the Amazon
certificate approval website and then clicking I Approve. However, the validation email can
be blocked by spam filters. Therefore, if you do not receive the original mail, you can
request that the mail be resent within 72 hours of requesting the ACM certificate. If more
than 72 hours have elapsed since your original request or since your last attempt to resend
validation mail, you must request a new certificate. For more information about setting up
your contact email addresses, see Configure Email for your Domain.
# Arguments
- `certificate_arn`: String that contains the ARN of the requested certificate. The
certificate ARN is generated and returned by the RequestCertificate action as soon as the
request is made. By default, using this parameter causes email to be sent to all top-level
domains you specified in the certificate request. The ARN must be of the form:
arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012
- `domain`: The fully qualified domain name (FQDN) of the certificate that needs to be
validated.
- `validation_domain`: The base validation domain that will act as the suffix of the email
addresses that are used to send the emails. This must be the same as the Domain value or a
superdomain of the Domain value. For example, if you requested a certificate for
site.subdomain.example.com and specify a ValidationDomain of subdomain.example.com, ACM
sends email to the domain registrant, technical contact, and administrative contact in
WHOIS and the following five addresses: [email protected]
[email protected] [email protected]
[email protected] [email protected]
"""
function resend_validation_email(
CertificateArn,
Domain,
ValidationDomain;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"ResendValidationEmail",
Dict{String,Any}(
"CertificateArn" => CertificateArn,
"Domain" => Domain,
"ValidationDomain" => ValidationDomain,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function resend_validation_email(
CertificateArn,
Domain,
ValidationDomain,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"ResendValidationEmail",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateArn" => CertificateArn,
"Domain" => Domain,
"ValidationDomain" => ValidationDomain,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_certificate_options(certificate_arn, options)
update_certificate_options(certificate_arn, options, params::Dict{String,<:Any})
Updates a certificate. Currently, you can use this function to specify whether to opt in to
or out of recording your certificate in a certificate transparency log. For more
information, see Opting Out of Certificate Transparency Logging.
# Arguments
- `certificate_arn`: ARN of the requested certificate to update. This must be of the form:
arn:aws:acm:us-east-1:account:certificate/12345678-1234-1234-1234-123456789012
- `options`: Use to update the options for your certificate. Currently, you can specify
whether to add your certificate to a transparency log. Certificate transparency makes it
possible to detect SSL/TLS certificates that have been mistakenly or maliciously issued.
Certificates that have not been logged typically produce an error message in a browser.
"""
function update_certificate_options(
CertificateArn, Options; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm(
"UpdateCertificateOptions",
Dict{String,Any}("CertificateArn" => CertificateArn, "Options" => Options);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_certificate_options(
CertificateArn,
Options,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm(
"UpdateCertificateOptions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateArn" => CertificateArn, "Options" => Options),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 66613 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: acm_pca
using AWS.Compat
using AWS.UUIDs
"""
create_certificate_authority(certificate_authority_configuration, certificate_authority_type)
create_certificate_authority(certificate_authority_configuration, certificate_authority_type, params::Dict{String,<:Any})
Creates a root or subordinate private certificate authority (CA). You must specify the CA
configuration, an optional configuration for Online Certificate Status Protocol (OCSP)
and/or a certificate revocation list (CRL), the CA type, and an optional idempotency token
to avoid accidental creation of multiple CAs. The CA configuration specifies the name of
the algorithm and key size to be used to create the CA private key, the type of signing
algorithm that the CA uses, and X.500 subject information. The OCSP configuration can
optionally specify a custom URL for the OCSP responder. The CRL configuration specifies the
CRL expiration period in days (the validity period of the CRL), the Amazon S3 bucket that
will contain the CRL, and a CNAME alias for the S3 bucket that is included in certificates
issued by the CA. If successful, this action returns the Amazon Resource Name (ARN) of the
CA. Both Amazon Web Services Private CA and the IAM principal must have permission to
write to the S3 bucket that you specify. If the IAM principal making the call does not have
permission to write to the bucket, then an exception is thrown. For more information, see
Access policies for CRLs in Amazon S3. Amazon Web Services Private CA assets that are
stored in Amazon S3 can be protected with encryption. For more information, see Encrypting
Your CRLs.
# Arguments
- `certificate_authority_configuration`: Name and bit size of the private key algorithm,
the name of the signing algorithm, and X.500 certificate subject information.
- `certificate_authority_type`: The type of the certificate authority.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: Custom string that can be used to distinguish between calls to the
CreateCertificateAuthority action. Idempotency tokens for CreateCertificateAuthority time
out after five minutes. Therefore, if you call CreateCertificateAuthority multiple times
with the same idempotency token within five minutes, Amazon Web Services Private CA
recognizes that you are requesting only certificate authority and will issue only one. If
you change the idempotency token for each call, Amazon Web Services Private CA recognizes
that you are requesting multiple certificate authorities.
- `"KeyStorageSecurityStandard"`: Specifies a cryptographic key management compliance
standard used for handling CA keys. Default: FIPS_140_2_LEVEL_3_OR_HIGHER Some Amazon Web
Services Regions do not support the default. When creating a CA in these Regions, you must
provide FIPS_140_2_LEVEL_2_OR_HIGHER as the argument for KeyStorageSecurityStandard.
Failure to do this results in an InvalidArgsException with the message, \"A certificate
authority cannot be created in this region with the specified security standard.\" For
information about security standard support in various Regions, see Storage and security
compliance of Amazon Web Services Private CA private keys.
- `"RevocationConfiguration"`: Contains information to enable Online Certificate Status
Protocol (OCSP) support, to enable a certificate revocation list (CRL), to enable both, or
to enable neither. The default is for both certificate validation mechanisms to be
disabled. The following requirements apply to revocation configurations. A
configuration disabling CRLs or OCSP must contain only the Enabled=False parameter, and
will fail if other parameters such as CustomCname or ExpirationInDays are included. In a
CRL configuration, the S3BucketName parameter must conform to Amazon S3 bucket naming
rules. A configuration containing a custom Canonical Name (CNAME) parameter for CRLs or
OCSP must conform to RFC2396 restrictions on the use of special characters in a CNAME.
In a CRL or OCSP configuration, the value of a CNAME parameter must not include a protocol
prefix such as \"http://\" or \"https://\". For more information, see the
OcspConfiguration and CrlConfiguration types.
- `"Tags"`: Key-value pairs that will be attached to the new private CA. You can associate
up to 50 tags with a private CA. For information using tags with IAM to manage permissions,
see Controlling Access Using IAM Tags.
- `"UsageMode"`: Specifies whether the CA issues general-purpose certificates that
typically require a revocation mechanism, or short-lived certificates that may optionally
omit revocation because they expire quickly. Short-lived certificate validity is limited to
seven days. The default value is GENERAL_PURPOSE.
"""
function create_certificate_authority(
CertificateAuthorityConfiguration,
CertificateAuthorityType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreateCertificateAuthority",
Dict{String,Any}(
"CertificateAuthorityConfiguration" => CertificateAuthorityConfiguration,
"CertificateAuthorityType" => CertificateAuthorityType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_certificate_authority(
CertificateAuthorityConfiguration,
CertificateAuthorityType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreateCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityConfiguration" =>
CertificateAuthorityConfiguration,
"CertificateAuthorityType" => CertificateAuthorityType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_certificate_authority_audit_report(audit_report_response_format, certificate_authority_arn, s3_bucket_name)
create_certificate_authority_audit_report(audit_report_response_format, certificate_authority_arn, s3_bucket_name, params::Dict{String,<:Any})
Creates an audit report that lists every time that your CA private key is used. The report
is saved in the Amazon S3 bucket that you specify on input. The IssueCertificate and
RevokeCertificate actions use the private key. Both Amazon Web Services Private CA and
the IAM principal must have permission to write to the S3 bucket that you specify. If the
IAM principal making the call does not have permission to write to the bucket, then an
exception is thrown. For more information, see Access policies for CRLs in Amazon S3.
Amazon Web Services Private CA assets that are stored in Amazon S3 can be protected with
encryption. For more information, see Encrypting Your Audit Reports. You can generate a
maximum of one report every 30 minutes.
# Arguments
- `audit_report_response_format`: The format in which to create the report. This can be
either JSON or CSV.
- `certificate_authority_arn`: The Amazon Resource Name (ARN) of the CA to be audited. This
is of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
- `s3_bucket_name`: The name of the S3 bucket that will contain the audit report.
"""
function create_certificate_authority_audit_report(
AuditReportResponseFormat,
CertificateAuthorityArn,
S3BucketName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreateCertificateAuthorityAuditReport",
Dict{String,Any}(
"AuditReportResponseFormat" => AuditReportResponseFormat,
"CertificateAuthorityArn" => CertificateAuthorityArn,
"S3BucketName" => S3BucketName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_certificate_authority_audit_report(
AuditReportResponseFormat,
CertificateAuthorityArn,
S3BucketName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreateCertificateAuthorityAuditReport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuditReportResponseFormat" => AuditReportResponseFormat,
"CertificateAuthorityArn" => CertificateAuthorityArn,
"S3BucketName" => S3BucketName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_permission(actions, certificate_authority_arn, principal)
create_permission(actions, certificate_authority_arn, principal, params::Dict{String,<:Any})
Grants one or more permissions on a private CA to the Certificate Manager (ACM) service
principal (acm.amazonaws.com). These permissions allow ACM to issue and renew ACM
certificates that reside in the same Amazon Web Services account as the CA. You can list
current permissions with the ListPermissions action and revoke them with the
DeletePermission action. About Permissions If the private CA and the certificates it
issues reside in the same account, you can use CreatePermission to grant permissions for
ACM to carry out automatic certificate renewals. For automatic certificate renewal to
succeed, the ACM service principal needs permissions to create, retrieve, and list
certificates. If the private CA and the ACM certificates reside in different accounts,
then permissions cannot be used to enable automatic renewals. Instead, the ACM certificate
owner must set up a resource-based policy to enable cross-account issuance and renewals.
For more information, see Using a Resource Based Policy with Amazon Web Services Private
CA.
# Arguments
- `actions`: The actions that the specified Amazon Web Services service principal can use.
These include IssueCertificate, GetCertificate, and ListPermissions.
- `certificate_authority_arn`: The Amazon Resource Name (ARN) of the CA that grants the
permissions. You can find the ARN by calling the ListCertificateAuthorities action. This
must have the following form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
- `principal`: The Amazon Web Services service or identity that receives the permission. At
this time, the only valid principal is acm.amazonaws.com.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SourceAccount"`: The ID of the calling account.
"""
function create_permission(
Actions,
CertificateAuthorityArn,
Principal;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreatePermission",
Dict{String,Any}(
"Actions" => Actions,
"CertificateAuthorityArn" => CertificateAuthorityArn,
"Principal" => Principal,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_permission(
Actions,
CertificateAuthorityArn,
Principal,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"CreatePermission",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Actions" => Actions,
"CertificateAuthorityArn" => CertificateAuthorityArn,
"Principal" => Principal,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_certificate_authority(certificate_authority_arn)
delete_certificate_authority(certificate_authority_arn, params::Dict{String,<:Any})
Deletes a private certificate authority (CA). You must provide the Amazon Resource Name
(ARN) of the private CA that you want to delete. You can find the ARN by calling the
ListCertificateAuthorities action. Deleting a CA will invalidate other CAs and
certificates below it in your CA hierarchy. Before you can delete a CA that you have
created and activated, you must disable it. To do this, call the UpdateCertificateAuthority
action and set the CertificateAuthorityStatus parameter to DISABLED. Additionally, you can
delete a CA if you are waiting for it to be created (that is, the status of the CA is
CREATING). You can also delete it if the CA has been created but you haven't yet imported
the signed certificate into Amazon Web Services Private CA (that is, the status of the CA
is PENDING_CERTIFICATE). When you successfully call DeleteCertificateAuthority, the CA's
status changes to DELETED. However, the CA won't be permanently deleted until the
restoration period has passed. By default, if you do not set the
PermanentDeletionTimeInDays parameter, the CA remains restorable for 30 days. You can set
the parameter from 7 to 30 days. The DescribeCertificateAuthority action returns the time
remaining in the restoration window of a private CA in the DELETED state. To restore an
eligible CA, call the RestoreCertificateAuthority action.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must have the following form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PermanentDeletionTimeInDays"`: The number of days to make a CA restorable after it has
been deleted. This can be anywhere from 7 to 30 days, with 30 being the default.
"""
function delete_certificate_authority(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"DeleteCertificateAuthority",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_certificate_authority(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DeleteCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_permission(certificate_authority_arn, principal)
delete_permission(certificate_authority_arn, principal, params::Dict{String,<:Any})
Revokes permissions on a private CA granted to the Certificate Manager (ACM) service
principal (acm.amazonaws.com). These permissions allow ACM to issue and renew ACM
certificates that reside in the same Amazon Web Services account as the CA. If you revoke
these permissions, ACM will no longer renew the affected certificates automatically.
Permissions can be granted with the CreatePermission action and listed with the
ListPermissions action. About Permissions If the private CA and the certificates it
issues reside in the same account, you can use CreatePermission to grant permissions for
ACM to carry out automatic certificate renewals. For automatic certificate renewal to
succeed, the ACM service principal needs permissions to create, retrieve, and list
certificates. If the private CA and the ACM certificates reside in different accounts,
then permissions cannot be used to enable automatic renewals. Instead, the ACM certificate
owner must set up a resource-based policy to enable cross-account issuance and renewals.
For more information, see Using a Resource Based Policy with Amazon Web Services Private
CA.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Number (ARN) of the private CA that
issued the permissions. You can find the CA's ARN by calling the ListCertificateAuthorities
action. This must have the following form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
- `principal`: The Amazon Web Services service or identity that will have its CA
permissions revoked. At this time, the only valid service principal is acm.amazonaws.com
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SourceAccount"`: The Amazon Web Services account that calls this action.
"""
function delete_permission(
CertificateAuthorityArn, Principal; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"DeletePermission",
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn, "Principal" => Principal
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_permission(
CertificateAuthorityArn,
Principal,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DeletePermission",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn,
"Principal" => Principal,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_policy(resource_arn)
delete_policy(resource_arn, params::Dict{String,<:Any})
Deletes the resource-based policy attached to a private CA. Deletion will remove any access
that the policy has granted. If there is no policy attached to the private CA, this action
will return successful. If you delete a policy that was applied through Amazon Web Services
Resource Access Manager (RAM), the CA will be removed from all shares in which it was
included. The Certificate Manager Service Linked Role that the policy supports is not
affected when you delete the policy. The current policy can be shown with GetPolicy and
updated with PutPolicy. About Policies A policy grants access on a private CA to an
Amazon Web Services customer account, to Amazon Web Services Organizations, or to an Amazon
Web Services Organizations unit. Policies are under the control of a CA administrator. For
more information, see Using a Resource Based Policy with Amazon Web Services Private CA.
A policy permits a user of Certificate Manager (ACM) to issue ACM certificates signed by a
CA in another account. For ACM to manage automatic renewal of these certificates, the ACM
user must configure a Service Linked Role (SLR). The SLR allows the ACM service to assume
the identity of the user, subject to confirmation against the Amazon Web Services Private
CA policy. For more information, see Using a Service Linked Role with ACM. Updates made
in Amazon Web Services Resource Manager (RAM) are reflected in policies. For more
information, see Attach a Policy for Cross-Account Access.
# Arguments
- `resource_arn`: The Amazon Resource Number (ARN) of the private CA that will have its
policy deleted. You can find the CA's ARN by calling the ListCertificateAuthorities action.
The ARN value must have the form
arn:aws:acm-pca:region:account:certificate-authority/01234567-89ab-cdef-0123-0123456789ab.
"""
function delete_policy(ResourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return acm_pca(
"DeletePolicy",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_policy(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DeletePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_certificate_authority(certificate_authority_arn)
describe_certificate_authority(certificate_authority_arn, params::Dict{String,<:Any})
Lists information about your private certificate authority (CA) or one that has been shared
with you. You specify the private CA on input by its ARN (Amazon Resource Name). The output
contains the status of your CA. This can be any of the following: CREATING - Amazon Web
Services Private CA is creating your private certificate authority. PENDING_CERTIFICATE
- The certificate is pending. You must use your Amazon Web Services Private CA-hosted or
on-premises root or subordinate CA to sign your private CA CSR and then import it into
Amazon Web Services Private CA. ACTIVE - Your private CA is active. DISABLED - Your
private CA has been disabled. EXPIRED - Your private CA certificate has expired.
FAILED - Your private CA has failed. Your CA can fail because of problems such a network
outage or back-end Amazon Web Services failure or other errors. A failed CA can never
return to the pending state. You must create a new CA. DELETED - Your private CA is
within the restoration period, after which it is permanently deleted. The length of time
remaining in the CA's restoration period is also included in this action's output.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
"""
function describe_certificate_authority(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"DescribeCertificateAuthority",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_certificate_authority(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DescribeCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_certificate_authority_audit_report(audit_report_id, certificate_authority_arn)
describe_certificate_authority_audit_report(audit_report_id, certificate_authority_arn, params::Dict{String,<:Any})
Lists information about a specific audit report created by calling the
CreateCertificateAuthorityAuditReport action. Audit information is created every time the
certificate authority (CA) private key is used. The private key is used when you call the
IssueCertificate action or the RevokeCertificate action.
# Arguments
- `audit_report_id`: The report ID returned by calling the
CreateCertificateAuthorityAuditReport action.
- `certificate_authority_arn`: The Amazon Resource Name (ARN) of the private CA. This must
be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
"""
function describe_certificate_authority_audit_report(
AuditReportId,
CertificateAuthorityArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DescribeCertificateAuthorityAuditReport",
Dict{String,Any}(
"AuditReportId" => AuditReportId,
"CertificateAuthorityArn" => CertificateAuthorityArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_certificate_authority_audit_report(
AuditReportId,
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"DescribeCertificateAuthorityAuditReport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuditReportId" => AuditReportId,
"CertificateAuthorityArn" => CertificateAuthorityArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_certificate(certificate_arn, certificate_authority_arn)
get_certificate(certificate_arn, certificate_authority_arn, params::Dict{String,<:Any})
Retrieves a certificate from your private CA or one that has been shared with you. The ARN
of the certificate is returned when you call the IssueCertificate action. You must specify
both the ARN of your private CA and the ARN of the issued certificate when calling the
GetCertificate action. You can retrieve the certificate if it is in the ISSUED state. You
can call the CreateCertificateAuthorityAuditReport action to create a report that contains
information about all of the certificates issued and revoked by your private CA.
# Arguments
- `certificate_arn`: The ARN of the issued certificate. The ARN contains the certificate
serial number and must be in the following form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012/ce
rtificate/286535153982981100925020015808220737245
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
"""
function get_certificate(
CertificateArn,
CertificateAuthorityArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"GetCertificate",
Dict{String,Any}(
"CertificateArn" => CertificateArn,
"CertificateAuthorityArn" => CertificateAuthorityArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_certificate(
CertificateArn,
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"GetCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateArn" => CertificateArn,
"CertificateAuthorityArn" => CertificateAuthorityArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_certificate_authority_certificate(certificate_authority_arn)
get_certificate_authority_certificate(certificate_authority_arn, params::Dict{String,<:Any})
Retrieves the certificate and certificate chain for your private certificate authority (CA)
or one that has been shared with you. Both the certificate and the chain are base64
PEM-encoded. The chain does not include the CA certificate. Each certificate in the chain
signs the one before it.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) of your private CA. This is
of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012 .
"""
function get_certificate_authority_certificate(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"GetCertificateAuthorityCertificate",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_certificate_authority_certificate(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"GetCertificateAuthorityCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_certificate_authority_csr(certificate_authority_arn)
get_certificate_authority_csr(certificate_authority_arn, params::Dict{String,<:Any})
Retrieves the certificate signing request (CSR) for your private certificate authority
(CA). The CSR is created when you call the CreateCertificateAuthority action. Sign the CSR
with your Amazon Web Services Private CA-hosted or on-premises root or subordinate CA. Then
import the signed certificate back into Amazon Web Services Private CA by calling the
ImportCertificateAuthorityCertificate action. The CSR is returned as a base64 PEM-encoded
string.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called the CreateCertificateAuthority action. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
"""
function get_certificate_authority_csr(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"GetCertificateAuthorityCsr",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_certificate_authority_csr(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"GetCertificateAuthorityCsr",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_policy(resource_arn)
get_policy(resource_arn, params::Dict{String,<:Any})
Retrieves the resource-based policy attached to a private CA. If either the private CA
resource or the policy cannot be found, this action returns a ResourceNotFoundException.
The policy can be attached or updated with PutPolicy and removed with DeletePolicy. About
Policies A policy grants access on a private CA to an Amazon Web Services customer
account, to Amazon Web Services Organizations, or to an Amazon Web Services Organizations
unit. Policies are under the control of a CA administrator. For more information, see Using
a Resource Based Policy with Amazon Web Services Private CA. A policy permits a user of
Certificate Manager (ACM) to issue ACM certificates signed by a CA in another account.
For ACM to manage automatic renewal of these certificates, the ACM user must configure a
Service Linked Role (SLR). The SLR allows the ACM service to assume the identity of the
user, subject to confirmation against the Amazon Web Services Private CA policy. For more
information, see Using a Service Linked Role with ACM. Updates made in Amazon Web
Services Resource Manager (RAM) are reflected in policies. For more information, see Attach
a Policy for Cross-Account Access.
# Arguments
- `resource_arn`: The Amazon Resource Number (ARN) of the private CA that will have its
policy retrieved. You can find the CA's ARN by calling the ListCertificateAuthorities
action.
"""
function get_policy(ResourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return acm_pca(
"GetPolicy",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_policy(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"GetPolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_certificate_authority_certificate(certificate, certificate_authority_arn)
import_certificate_authority_certificate(certificate, certificate_authority_arn, params::Dict{String,<:Any})
Imports a signed private CA certificate into Amazon Web Services Private CA. This action is
used when you are using a chain of trust whose root is located outside Amazon Web Services
Private CA. Before you can call this action, the following preparations must in place: In
Amazon Web Services Private CA, call the CreateCertificateAuthority action to create the
private CA that you plan to back with the imported certificate. Call the
GetCertificateAuthorityCsr action to generate a certificate signing request (CSR). Sign
the CSR using a root or intermediate CA hosted by either an on-premises PKI hierarchy or by
a commercial CA. Create a certificate chain and copy the signed certificate and the
certificate chain to your working directory. Amazon Web Services Private CA supports
three scenarios for installing a CA certificate: Installing a certificate for a root CA
hosted by Amazon Web Services Private CA. Installing a subordinate CA certificate whose
parent authority is hosted by Amazon Web Services Private CA. Installing a subordinate CA
certificate whose parent authority is externally hosted. The following additional
requirements apply when you import a CA certificate. Only a self-signed certificate can
be imported as a root CA. A self-signed certificate cannot be imported as a subordinate
CA. Your certificate chain must not include the private CA certificate that you are
importing. Your root CA must be the last certificate in your chain. The subordinate
certificate, if any, that your root CA signed must be next to last. The subordinate
certificate signed by the preceding subordinate CA must come next, and so on until your
chain is built. The chain must be PEM-encoded. The maximum allowed size of a
certificate is 32 KB. The maximum allowed size of a certificate chain is 2 MB.
Enforcement of Critical Constraints Amazon Web Services Private CA allows the following
extensions to be marked critical in the imported CA certificate or chain. Authority key
identifier Basic constraints (must be marked critical) Certificate policies Extended
key usage Inhibit anyPolicy Issuer alternative name Key usage Name constraints
Policy mappings Subject alternative name Subject directory attributes Subject key
identifier Subject information access Amazon Web Services Private CA rejects the
following extensions when they are marked critical in an imported CA certificate or chain.
Authority information access CRL distribution points Freshest CRL Policy constraints
Amazon Web Services Private Certificate Authority will also reject any other extension
marked as critical not contained on the preceding list of allowed extensions.
# Arguments
- `certificate`: The PEM-encoded certificate for a private CA. This may be a self-signed
certificate in the case of a root CA, or it may be signed by another CA that you control.
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateChain"`: A PEM-encoded file that contains all of your certificates, other
than the certificate you're importing, chaining up to your root CA. Your Amazon Web
Services Private CA-hosted or on-premises root certificate is the last in the chain, and
each certificate in the chain signs the one preceding. This parameter must be supplied
when you import a subordinate CA. When you import a root CA, there is no chain.
"""
function import_certificate_authority_certificate(
Certificate, CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"ImportCertificateAuthorityCertificate",
Dict{String,Any}(
"Certificate" => Certificate,
"CertificateAuthorityArn" => CertificateAuthorityArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_certificate_authority_certificate(
Certificate,
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"ImportCertificateAuthorityCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Certificate" => Certificate,
"CertificateAuthorityArn" => CertificateAuthorityArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
issue_certificate(certificate_authority_arn, csr, signing_algorithm, validity)
issue_certificate(certificate_authority_arn, csr, signing_algorithm, validity, params::Dict{String,<:Any})
Uses your private certificate authority (CA), or one that has been shared with you, to
issue a client certificate. This action returns the Amazon Resource Name (ARN) of the
certificate. You can retrieve the certificate by calling the GetCertificate action and
specifying the ARN. You cannot use the ACM ListCertificateAuthorities action to retrieve
the ARNs of the certificates that you issue by using Amazon Web Services Private CA.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
- `csr`: The certificate signing request (CSR) for the certificate you want to issue. As an
example, you can use the following OpenSSL command to create the CSR and a 2048 bit RSA
private key. openssl req -new -newkey rsa:2048 -days 365 -keyout
private/test_cert_priv_key.pem -out csr/test_cert_.csr If you have a configuration file,
you can then use the following OpenSSL command. The usr_cert block in the configuration
file contains your X509 version 3 extensions. openssl req -new -config openssl_rsa.cnf
-extensions usr_cert -newkey rsa:2048 -days 365 -keyout private/test_cert_priv_key.pem -out
csr/test_cert_.csr Note: A CSR must provide either a subject name or a subject alternative
name or the request will be rejected.
- `signing_algorithm`: The name of the algorithm that will be used to sign the certificate
to be issued. This parameter should not be confused with the SigningAlgorithm parameter
used to sign a CSR in the CreateCertificateAuthority action. The specified signing
algorithm family (RSA or ECDSA) must match the algorithm family of the CA's secret key.
- `validity`: Information describing the end of the validity period of the certificate.
This parameter sets the “Not After” date for the certificate. Certificate validity is
the period of time during which a certificate is valid. Validity can be expressed as an
explicit date and time when the certificate expires, or as a span of time after issuance,
stated in days, months, or years. For more information, see Validity in RFC 5280. This
value is unaffected when ValidityNotBefore is also specified. For example, if Validity is
set to 20 days in the future, the certificate will expire 20 days from issuance time
regardless of the ValidityNotBefore value. The end of the validity period configured on a
certificate must not exceed the limit set on its parents in the CA hierarchy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApiPassthrough"`: Specifies X.509 certificate information to be included in the issued
certificate. An APIPassthrough or APICSRPassthrough template variant must be selected, or
else this parameter is ignored. For more information about using these templates, see
Understanding Certificate Templates. If conflicting or duplicate certificate information is
supplied during certificate issuance, Amazon Web Services Private CA applies order of
operation rules to determine what information is used.
- `"IdempotencyToken"`: Alphanumeric string that can be used to distinguish between calls
to the IssueCertificate action. Idempotency tokens for IssueCertificate time out after five
minutes. Therefore, if you call IssueCertificate multiple times with the same idempotency
token within five minutes, Amazon Web Services Private CA recognizes that you are
requesting only one certificate and will issue only one. If you change the idempotency
token for each call, Amazon Web Services Private CA recognizes that you are requesting
multiple certificates.
- `"TemplateArn"`: Specifies a custom configuration template to use when issuing a
certificate. If this parameter is not provided, Amazon Web Services Private CA defaults to
the EndEntityCertificate/V1 template. For CA certificates, you should choose the shortest
path length that meets your needs. The path length is indicated by the PathLenN portion of
the ARN, where N is the CA depth. Note: The CA depth configured on a subordinate CA
certificate must not exceed the limit set by its parents in the CA hierarchy. For a list of
TemplateArn values supported by Amazon Web Services Private CA, see Understanding
Certificate Templates.
- `"ValidityNotBefore"`: Information describing the start of the validity period of the
certificate. This parameter sets the “Not Before\" date for the certificate. By default,
when issuing a certificate, Amazon Web Services Private CA sets the \"Not Before\" date to
the issuance time minus 60 minutes. This compensates for clock inconsistencies across
computer systems. The ValidityNotBefore parameter can be used to customize the “Not
Before” value. Unlike the Validity parameter, the ValidityNotBefore parameter is
optional. The ValidityNotBefore value is expressed as an explicit date and time, using the
Validity type value ABSOLUTE. For more information, see Validity in this API reference and
Validity in RFC 5280.
"""
function issue_certificate(
CertificateAuthorityArn,
Csr,
SigningAlgorithm,
Validity;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"IssueCertificate",
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn,
"Csr" => Csr,
"SigningAlgorithm" => SigningAlgorithm,
"Validity" => Validity,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function issue_certificate(
CertificateAuthorityArn,
Csr,
SigningAlgorithm,
Validity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"IssueCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn,
"Csr" => Csr,
"SigningAlgorithm" => SigningAlgorithm,
"Validity" => Validity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_certificate_authorities()
list_certificate_authorities(params::Dict{String,<:Any})
Lists the private certificate authorities that you created by using the
CreateCertificateAuthority action.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Use this parameter when paginating results to specify the maximum number
of items to return in the response on each page. If additional items exist beyond the
number you specify, the NextToken element is sent in the response. Use this NextToken value
in a subsequent request to retrieve additional items. Although the maximum value is 1000,
the action only returns a maximum of 100 items.
- `"NextToken"`: Use this parameter when paginating results in a subsequent request after
you receive a response with truncated results. Set it to the value of the NextToken
parameter from the response you just received.
- `"ResourceOwner"`: Use this parameter to filter the returned set of certificate
authorities based on their owner. The default is SELF.
"""
function list_certificate_authorities(; aws_config::AbstractAWSConfig=global_aws_config())
return acm_pca(
"ListCertificateAuthorities"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_certificate_authorities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"ListCertificateAuthorities",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_permissions(certificate_authority_arn)
list_permissions(certificate_authority_arn, params::Dict{String,<:Any})
List all permissions on a private CA, if any, granted to the Certificate Manager (ACM)
service principal (acm.amazonaws.com). These permissions allow ACM to issue and renew ACM
certificates that reside in the same Amazon Web Services account as the CA. Permissions
can be granted with the CreatePermission action and revoked with the DeletePermission
action. About Permissions If the private CA and the certificates it issues reside in
the same account, you can use CreatePermission to grant permissions for ACM to carry out
automatic certificate renewals. For automatic certificate renewal to succeed, the ACM
service principal needs permissions to create, retrieve, and list certificates. If the
private CA and the ACM certificates reside in different accounts, then permissions cannot
be used to enable automatic renewals. Instead, the ACM certificate owner must set up a
resource-based policy to enable cross-account issuance and renewals. For more information,
see Using a Resource Based Policy with Amazon Web Services Private CA.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Number (ARN) of the private CA to
inspect. You can find the ARN by calling the ListCertificateAuthorities action. This must
be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
You can get a private CA's ARN by running the ListCertificateAuthorities action.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: When paginating results, use this parameter to specify the maximum number
of items to return in the response. If additional items exist beyond the number you
specify, the NextToken element is sent in the response. Use this NextToken value in a
subsequent request to retrieve additional items.
- `"NextToken"`: When paginating results, use this parameter in a subsequent request after
you receive a response with truncated results. Set it to the value of NextToken from the
response you just received.
"""
function list_permissions(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"ListPermissions",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_permissions(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"ListPermissions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags(certificate_authority_arn)
list_tags(certificate_authority_arn, params::Dict{String,<:Any})
Lists the tags, if any, that are associated with your private CA or one that has been
shared with you. Tags are labels that you can use to identify and organize your CAs. Each
tag consists of a key and an optional value. Call the TagCertificateAuthority action to add
one or more tags to your CA. Call the UntagCertificateAuthority action to remove tags.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called the CreateCertificateAuthority action. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Use this parameter when paginating results to specify the maximum number
of items to return in the response. If additional items exist beyond the number you
specify, the NextToken element is sent in the response. Use this NextToken value in a
subsequent request to retrieve additional items.
- `"NextToken"`: Use this parameter when paginating results in a subsequent request after
you receive a response with truncated results. Set it to the value of NextToken from the
response you just received.
"""
function list_tags(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"ListTags",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"ListTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_policy(policy, resource_arn)
put_policy(policy, resource_arn, params::Dict{String,<:Any})
Attaches a resource-based policy to a private CA. A policy can also be applied by sharing
a private CA through Amazon Web Services Resource Access Manager (RAM). For more
information, see Attach a Policy for Cross-Account Access. The policy can be displayed with
GetPolicy and removed with DeletePolicy. About Policies A policy grants access on a
private CA to an Amazon Web Services customer account, to Amazon Web Services
Organizations, or to an Amazon Web Services Organizations unit. Policies are under the
control of a CA administrator. For more information, see Using a Resource Based Policy with
Amazon Web Services Private CA. A policy permits a user of Certificate Manager (ACM) to
issue ACM certificates signed by a CA in another account. For ACM to manage automatic
renewal of these certificates, the ACM user must configure a Service Linked Role (SLR). The
SLR allows the ACM service to assume the identity of the user, subject to confirmation
against the Amazon Web Services Private CA policy. For more information, see Using a
Service Linked Role with ACM. Updates made in Amazon Web Services Resource Manager (RAM)
are reflected in policies. For more information, see Attach a Policy for Cross-Account
Access.
# Arguments
- `policy`: The path and file name of a JSON-formatted IAM policy to attach to the
specified private CA resource. If this policy does not contain all required statements or
if it includes any statement that is not allowed, the PutPolicy action returns an
InvalidPolicyException. For information about IAM policy and statement structure, see
Overview of JSON Policies.
- `resource_arn`: The Amazon Resource Number (ARN) of the private CA to associate with the
policy. The ARN of the CA can be found by calling the ListCertificateAuthorities action.
"""
function put_policy(Policy, ResourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return acm_pca(
"PutPolicy",
Dict{String,Any}("Policy" => Policy, "ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_policy(
Policy,
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"PutPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Policy" => Policy, "ResourceArn" => ResourceArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
restore_certificate_authority(certificate_authority_arn)
restore_certificate_authority(certificate_authority_arn, params::Dict{String,<:Any})
Restores a certificate authority (CA) that is in the DELETED state. You can restore a CA
during the period that you defined in the PermanentDeletionTimeInDays parameter of the
DeleteCertificateAuthority action. Currently, you can specify 7 to 30 days. If you did not
specify a PermanentDeletionTimeInDays value, by default you can restore the CA at any time
in a 30 day period. You can check the time remaining in the restoration period of a private
CA in the DELETED state by calling the DescribeCertificateAuthority or
ListCertificateAuthorities actions. The status of a restored CA is set to its pre-deletion
status when the RestoreCertificateAuthority action returns. To change its status to ACTIVE,
call the UpdateCertificateAuthority action. If the private CA was in the
PENDING_CERTIFICATE state at deletion, you must use the
ImportCertificateAuthorityCertificate action to import a certificate authority into the
private CA before it can be activated. You cannot restore a CA after the restoration period
has ended.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called the CreateCertificateAuthority action. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
"""
function restore_certificate_authority(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"RestoreCertificateAuthority",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function restore_certificate_authority(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"RestoreCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
revoke_certificate(certificate_authority_arn, certificate_serial, revocation_reason)
revoke_certificate(certificate_authority_arn, certificate_serial, revocation_reason, params::Dict{String,<:Any})
Revokes a certificate that was issued inside Amazon Web Services Private CA. If you enable
a certificate revocation list (CRL) when you create or update your private CA, information
about the revoked certificates will be included in the CRL. Amazon Web Services Private CA
writes the CRL to an S3 bucket that you specify. A CRL is typically updated approximately
30 minutes after a certificate is revoked. If for any reason the CRL update fails, Amazon
Web Services Private CA attempts makes further attempts every 15 minutes. With Amazon
CloudWatch, you can create alarms for the metrics CRLGenerated and MisconfiguredCRLBucket.
For more information, see Supported CloudWatch Metrics. Both Amazon Web Services Private
CA and the IAM principal must have permission to write to the S3 bucket that you specify.
If the IAM principal making the call does not have permission to write to the bucket, then
an exception is thrown. For more information, see Access policies for CRLs in Amazon S3.
Amazon Web Services Private CA also writes revocation information to the audit report. For
more information, see CreateCertificateAuthorityAuditReport. You cannot revoke a root CA
self-signed certificate.
# Arguments
- `certificate_authority_arn`: Amazon Resource Name (ARN) of the private CA that issued the
certificate to be revoked. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
- `certificate_serial`: Serial number of the certificate to be revoked. This must be in
hexadecimal format. You can retrieve the serial number by calling GetCertificate with the
Amazon Resource Name (ARN) of the certificate you want and the ARN of your private CA. The
GetCertificate action retrieves the certificate in the PEM format. You can use the
following OpenSSL command to list the certificate in text format and copy the hexadecimal
serial number. openssl x509 -in file_path -text -noout You can also copy the serial
number from the console or use the DescribeCertificate action in the Certificate Manager
API Reference.
- `revocation_reason`: Specifies why you revoked the certificate.
"""
function revoke_certificate(
CertificateAuthorityArn,
CertificateSerial,
RevocationReason;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"RevokeCertificate",
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn,
"CertificateSerial" => CertificateSerial,
"RevocationReason" => RevocationReason,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function revoke_certificate(
CertificateAuthorityArn,
CertificateSerial,
RevocationReason,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"RevokeCertificate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn,
"CertificateSerial" => CertificateSerial,
"RevocationReason" => RevocationReason,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_certificate_authority(certificate_authority_arn, tags)
tag_certificate_authority(certificate_authority_arn, tags, params::Dict{String,<:Any})
Adds one or more tags to your private CA. Tags are labels that you can use to identify and
organize your Amazon Web Services resources. Each tag consists of a key and an optional
value. You specify the private CA on input by its Amazon Resource Name (ARN). You specify
the tag by using a key-value pair. You can apply a tag to just one private CA if you want
to identify a specific characteristic of that CA, or you can apply the same tag to multiple
private CAs if you want to filter for a common relationship among those CAs. To remove one
or more tags, use the UntagCertificateAuthority action. Call the ListTags action to see
what tags are associated with your CA. To attach tags to a private CA during the creation
procedure, a CA administrator must first associate an inline IAM policy with the
CreateCertificateAuthority action and explicitly allow tagging. For more information, see
Attaching tags to a CA at the time of creation.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
- `tags`: List of tags to be associated with the CA.
"""
function tag_certificate_authority(
CertificateAuthorityArn, Tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"TagCertificateAuthority",
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn, "Tags" => Tags
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_certificate_authority(
CertificateAuthorityArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"TagCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn, "Tags" => Tags
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_certificate_authority(certificate_authority_arn, tags)
untag_certificate_authority(certificate_authority_arn, tags, params::Dict{String,<:Any})
Remove one or more tags from your private CA. A tag consists of a key-value pair. If you do
not specify the value portion of the tag when calling this action, the tag will be removed
regardless of value. If you specify a value, the tag is removed only if it is associated
with the specified value. To add tags to a private CA, use the TagCertificateAuthority.
Call the ListTags action to see what tags are associated with your CA.
# Arguments
- `certificate_authority_arn`: The Amazon Resource Name (ARN) that was returned when you
called CreateCertificateAuthority. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
- `tags`: List of tags to be removed from the CA.
"""
function untag_certificate_authority(
CertificateAuthorityArn, Tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"UntagCertificateAuthority",
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn, "Tags" => Tags
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_certificate_authority(
CertificateAuthorityArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"UntagCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CertificateAuthorityArn" => CertificateAuthorityArn, "Tags" => Tags
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_certificate_authority(certificate_authority_arn)
update_certificate_authority(certificate_authority_arn, params::Dict{String,<:Any})
Updates the status or configuration of a private certificate authority (CA). Your private
CA must be in the ACTIVE or DISABLED state before you can update it. You can disable a
private CA that is in the ACTIVE state or make a CA that is in the DISABLED state active
again. Both Amazon Web Services Private CA and the IAM principal must have permission to
write to the S3 bucket that you specify. If the IAM principal making the call does not have
permission to write to the bucket, then an exception is thrown. For more information, see
Access policies for CRLs in Amazon S3.
# Arguments
- `certificate_authority_arn`: Amazon Resource Name (ARN) of the private CA that issued the
certificate to be revoked. This must be of the form:
arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RevocationConfiguration"`: Contains information to enable Online Certificate Status
Protocol (OCSP) support, to enable a certificate revocation list (CRL), to enable both, or
to enable neither. If this parameter is not supplied, existing capibilites remain
unchanged. For more information, see the OcspConfiguration and CrlConfiguration types. The
following requirements apply to revocation configurations. A configuration disabling CRLs
or OCSP must contain only the Enabled=False parameter, and will fail if other parameters
such as CustomCname or ExpirationInDays are included. In a CRL configuration, the
S3BucketName parameter must conform to Amazon S3 bucket naming rules. A configuration
containing a custom Canonical Name (CNAME) parameter for CRLs or OCSP must conform to
RFC2396 restrictions on the use of special characters in a CNAME. In a CRL or OCSP
configuration, the value of a CNAME parameter must not include a protocol prefix such as
\"http://\" or \"https://\".
- `"Status"`: Status of your private CA.
"""
function update_certificate_authority(
CertificateAuthorityArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return acm_pca(
"UpdateCertificateAuthority",
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_certificate_authority(
CertificateAuthorityArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return acm_pca(
"UpdateCertificateAuthority",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CertificateAuthorityArn" => CertificateAuthorityArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 38330 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: amp
using AWS.Compat
using AWS.UUIDs
"""
create_alert_manager_definition(data, workspace_id)
create_alert_manager_definition(data, workspace_id, params::Dict{String,<:Any})
The CreateAlertManagerDefinition operation creates the alert manager definition in a
workspace. If a workspace already has an alert manager definition, don't use this operation
to update it. Instead, use PutAlertManagerDefinition.
# Arguments
- `data`: The alert manager definition to add. A base64-encoded version of the YAML alert
manager definition file. For details about the alert manager definition, see
AlertManagedDefinitionData.
- `workspace_id`: The ID of the workspace to add the alert manager definition to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function create_alert_manager_definition(
data, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"POST",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}("data" => data, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_alert_manager_definition(
data,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("data" => data, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_logging_configuration(log_group_arn, workspace_id)
create_logging_configuration(log_group_arn, workspace_id, params::Dict{String,<:Any})
The CreateLoggingConfiguration operation creates a logging configuration for the workspace.
Use this operation to set the CloudWatch log group to which the logs will be published to.
# Arguments
- `log_group_arn`: The ARN of the CloudWatch log group to which the vended log data will be
published. This log group must exist prior to calling this API.
- `workspace_id`: The ID of the workspace to create the logging configuration for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function create_logging_configuration(
logGroupArn, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"POST",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}("logGroupArn" => logGroupArn, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_logging_configuration(
logGroupArn,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupArn" => logGroupArn, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_rule_groups_namespace(data, name, workspace_id)
create_rule_groups_namespace(data, name, workspace_id, params::Dict{String,<:Any})
The CreateRuleGroupsNamespace operation creates a rule groups namespace within a workspace.
A rule groups namespace is associated with exactly one rules file. A workspace can have
multiple rule groups namespaces. Use this operation only to create new rule groups
namespaces. To update an existing rule groups namespace, use PutRuleGroupsNamespace.
# Arguments
- `data`: The rules file to use in the new namespace. Contains the base64-encoded version
of the YAML rules file. For details about the rule groups namespace structure, see
RuleGroupsNamespaceData.
- `name`: The name for the new rule groups namespace.
- `workspace_id`: The ID of the workspace to add the rule groups namespace.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
- `"tags"`: The list of tag keys and values to associate with the rule groups namespace.
"""
function create_rule_groups_namespace(
data, name, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"POST",
"/workspaces/$(workspaceId)/rulegroupsnamespaces",
Dict{String,Any}("data" => data, "name" => name, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_rule_groups_namespace(
data,
name,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/workspaces/$(workspaceId)/rulegroupsnamespaces",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"data" => data, "name" => name, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_scraper(destination, scrape_configuration, source)
create_scraper(destination, scrape_configuration, source, params::Dict{String,<:Any})
The CreateScraper operation creates a scraper to collect metrics. A scraper pulls metrics
from Prometheus-compatible sources within an Amazon EKS cluster, and sends them to your
Amazon Managed Service for Prometheus workspace. You can configure the scraper to control
what metrics are collected, and what transformations are applied prior to sending them to
your workspace. If needed, an IAM role will be created for you that gives Amazon Managed
Service for Prometheus access to the metrics in your cluster. For more information, see
Using roles for scraping metrics from EKS in the Amazon Managed Service for Prometheus User
Guide. You cannot update a scraper. If you want to change the configuration of the scraper,
create a new scraper and delete the old one. The scrapeConfiguration parameter contains the
base64-encoded version of the YAML configuration file. For more information about
collectors, including what metrics are collected, and how to configure the scraper, see
Amazon Web Services managed collectors in the Amazon Managed Service for Prometheus User
Guide.
# Arguments
- `destination`: The Amazon Managed Service for Prometheus workspace to send metrics to.
- `scrape_configuration`: The configuration file to use in the new scraper. For more
information, see Scraper configuration in the Amazon Managed Service for Prometheus User
Guide.
- `source`: The Amazon EKS cluster from which the scraper will collect metrics.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: (optional) a name to associate with the scraper. This is for your use, and
does not need to be unique.
- `"clientToken"`: (Optional) A unique, case-sensitive identifier that you can provide to
ensure the idempotency of the request.
- `"tags"`: (Optional) The list of tag keys and values to associate with the scraper.
"""
function create_scraper(
destination,
scrapeConfiguration,
source;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/scrapers",
Dict{String,Any}(
"destination" => destination,
"scrapeConfiguration" => scrapeConfiguration,
"source" => source,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_scraper(
destination,
scrapeConfiguration,
source,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/scrapers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destination" => destination,
"scrapeConfiguration" => scrapeConfiguration,
"source" => source,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_workspace()
create_workspace(params::Dict{String,<:Any})
Creates a Prometheus workspace. A workspace is a logical space dedicated to the storage and
querying of Prometheus metrics. You can have one or more workspaces in each Region in your
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: An alias that you assign to this workspace to help you identify it. It does
not need to be unique. Blank spaces at the beginning or end of the alias that you specify
will be trimmed from the value used.
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
- `"kmsKeyArn"`: (optional) The ARN for a customer managed KMS key to use for encrypting
data within your workspace. For more information about using your own key in your
workspace, see Encryption at rest in the Amazon Managed Service for Prometheus User Guide.
- `"tags"`: The list of tag keys and values to associate with the workspace.
"""
function create_workspace(; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"POST",
"/workspaces",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_workspace(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"POST",
"/workspaces",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_alert_manager_definition(workspace_id)
delete_alert_manager_definition(workspace_id, params::Dict{String,<:Any})
Deletes the alert manager definition from a workspace.
# Arguments
- `workspace_id`: The ID of the workspace to delete the alert manager definition from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function delete_alert_manager_definition(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_alert_manager_definition(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_logging_configuration(workspace_id)
delete_logging_configuration(workspace_id, params::Dict{String,<:Any})
Deletes the logging configuration for a workspace.
# Arguments
- `workspace_id`: The ID of the workspace containing the logging configuration to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function delete_logging_configuration(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_logging_configuration(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_rule_groups_namespace(name, workspace_id)
delete_rule_groups_namespace(name, workspace_id, params::Dict{String,<:Any})
Deletes one rule groups namespace and its associated rule groups definition.
# Arguments
- `name`: The name of the rule groups namespace to delete.
- `workspace_id`: The ID of the workspace containing the rule groups namespace and
definition to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function delete_rule_groups_namespace(
name, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_rule_groups_namespace(
name,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_scraper(scraper_id)
delete_scraper(scraper_id, params::Dict{String,<:Any})
The DeleteScraper operation deletes one scraper, and stops any metrics collection that the
scraper performs.
# Arguments
- `scraper_id`: The ID of the scraper to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: (Optional) A unique, case-sensitive identifier that you can provide to
ensure the idempotency of the request.
"""
function delete_scraper(scraperId; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"DELETE",
"/scrapers/$(scraperId)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scraper(
scraperId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/scrapers/$(scraperId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_workspace(workspace_id)
delete_workspace(workspace_id, params::Dict{String,<:Any})
Deletes an existing workspace. When you delete a workspace, the data that has been
ingested into it is not immediately deleted. It will be permanently deleted within one
month.
# Arguments
- `workspace_id`: The ID of the workspace to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function delete_workspace(workspaceId; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"DELETE",
"/workspaces/$(workspaceId)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_workspace(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/workspaces/$(workspaceId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_alert_manager_definition(workspace_id)
describe_alert_manager_definition(workspace_id, params::Dict{String,<:Any})
Retrieves the full information about the alert manager definition for a workspace.
# Arguments
- `workspace_id`: The ID of the workspace to retrieve the alert manager definition from.
"""
function describe_alert_manager_definition(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/workspaces/$(workspaceId)/alertmanager/definition";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_alert_manager_definition(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/workspaces/$(workspaceId)/alertmanager/definition",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_logging_configuration(workspace_id)
describe_logging_configuration(workspace_id, params::Dict{String,<:Any})
Returns complete information about the current logging configuration of the workspace.
# Arguments
- `workspace_id`: The ID of the workspace to describe the logging configuration for.
"""
function describe_logging_configuration(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/workspaces/$(workspaceId)/logging";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_logging_configuration(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/workspaces/$(workspaceId)/logging",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_rule_groups_namespace(name, workspace_id)
describe_rule_groups_namespace(name, workspace_id, params::Dict{String,<:Any})
Returns complete information about one rule groups namespace. To retrieve a list of rule
groups namespaces, use ListRuleGroupsNamespaces.
# Arguments
- `name`: The name of the rule groups namespace that you want information for.
- `workspace_id`: The ID of the workspace containing the rule groups namespace.
"""
function describe_rule_groups_namespace(
name, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_rule_groups_namespace(
name,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scraper(scraper_id)
describe_scraper(scraper_id, params::Dict{String,<:Any})
The DescribeScraper operation displays information about an existing scraper.
# Arguments
- `scraper_id`: The ID of the scraper to describe.
"""
function describe_scraper(scraperId; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"GET",
"/scrapers/$(scraperId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scraper(
scraperId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/scrapers/$(scraperId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_workspace(workspace_id)
describe_workspace(workspace_id, params::Dict{String,<:Any})
Returns information about an existing workspace.
# Arguments
- `workspace_id`: The ID of the workspace to describe.
"""
function describe_workspace(workspaceId; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"GET",
"/workspaces/$(workspaceId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_workspace(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/workspaces/$(workspaceId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_default_scraper_configuration()
get_default_scraper_configuration(params::Dict{String,<:Any})
The GetDefaultScraperConfiguration operation returns the default scraper configuration used
when Amazon EKS creates a scraper for you.
"""
function get_default_scraper_configuration(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/scraperconfiguration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_default_scraper_configuration(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/scraperconfiguration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_rule_groups_namespaces(workspace_id)
list_rule_groups_namespaces(workspace_id, params::Dict{String,<:Any})
Returns a list of rule groups namespaces in a workspace.
# Arguments
- `workspace_id`: The ID of the workspace containing the rule groups namespaces.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return. The default is 100.
- `"name"`: Use this parameter to filter the rule groups namespaces that are returned. Only
the namespaces with names that begin with the value that you specify are returned.
- `"nextToken"`: The token for the next set of items to return. You receive this token from
a previous call, and use it to get the next page of results. The other parameters must be
the same as the initial call. For example, if your initial request has maxResults of 10,
and there are 12 rule groups namespaces to return, then your initial request will return 10
and a nextToken. Using the next token in a subsequent call will return the remaining 2
namespaces.
"""
function list_rule_groups_namespaces(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/workspaces/$(workspaceId)/rulegroupsnamespaces";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_rule_groups_namespaces(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/workspaces/$(workspaceId)/rulegroupsnamespaces",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_scrapers()
list_scrapers(params::Dict{String,<:Any})
The ListScrapers operation lists all of the scrapers in your account. This includes
scrapers being created or deleted. You can optionally filter the returned list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: (Optional) A list of key-value pairs to filter the list of scrapers
returned. Keys include status, sourceArn, destinationArn, and alias. Filters on the same
key are OR'd together, and filters on different keys are AND'd together. For example,
status=ACTIVE&status=CREATING&alias=Test, will return all scrapers that have the
alias Test, and are either in status ACTIVE or CREATING. To find all active scrapers that
are sending metrics to a specific Amazon Managed Service for Prometheus workspace, you
would use the ARN of the workspace in a query:
status=ACTIVE&destinationArn=arn:aws:aps:us-east-1:123456789012:workspace/ws-example1-12
34-abcd-56ef-123456789012 If this is included, it filters the results to only the scrapers
that match the filter.
- `"maxResults"`: Optional) The maximum number of scrapers to return in one ListScrapers
operation. The range is 1-1000. If you omit this parameter, the default of 100 is used.
- `"nextToken"`: (Optional) The token for the next set of items to return. (You received
this token from a previous call.)
"""
function list_scrapers(; aws_config::AbstractAWSConfig=global_aws_config())
return amp("GET", "/scrapers"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_scrapers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET", "/scrapers", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
The ListTagsForResource operation returns the tags that are associated with an Amazon
Managed Service for Prometheus resource. Currently, the only resources that can be tagged
are workspaces and rule groups namespaces.
# Arguments
- `resource_arn`: The ARN of the resource to list tages for. Must be a workspace or rule
groups namespace resource.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_workspaces()
list_workspaces(params::Dict{String,<:Any})
Lists all of the Amazon Managed Service for Prometheus workspaces in your account. This
includes workspaces being created or deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: If this is included, it filters the results to only the workspaces with names
that start with the value that you specify here. Amazon Managed Service for Prometheus will
automatically strip any blank spaces from the beginning and end of the alias that you
specify.
- `"maxResults"`: The maximum number of workspaces to return per request. The default is
100.
- `"nextToken"`: The token for the next set of items to return. You receive this token from
a previous call, and use it to get the next page of results. The other parameters must be
the same as the initial call. For example, if your initial request has maxResults of 10,
and there are 12 workspaces to return, then your initial request will return 10 and a
nextToken. Using the next token in a subsequent call will return the remaining 2 workspaces.
"""
function list_workspaces(; aws_config::AbstractAWSConfig=global_aws_config())
return amp("GET", "/workspaces"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_workspaces(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"GET", "/workspaces", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_alert_manager_definition(data, workspace_id)
put_alert_manager_definition(data, workspace_id, params::Dict{String,<:Any})
Updates an existing alert manager definition in a workspace. If the workspace does not
already have an alert manager definition, don't use this operation to create it. Instead,
use CreateAlertManagerDefinition.
# Arguments
- `data`: The alert manager definition to use. A base64-encoded version of the YAML alert
manager definition file. For details about the alert manager definition, see
AlertManagedDefinitionData.
- `workspace_id`: The ID of the workspace to update the alert manager definition in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function put_alert_manager_definition(
data, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}("data" => data, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_alert_manager_definition(
data,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/alertmanager/definition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("data" => data, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_rule_groups_namespace(data, name, workspace_id)
put_rule_groups_namespace(data, name, workspace_id, params::Dict{String,<:Any})
Updates an existing rule groups namespace within a workspace. A rule groups namespace is
associated with exactly one rules file. A workspace can have multiple rule groups
namespaces. Use this operation only to update existing rule groups namespaces. To create a
new rule groups namespace, use CreateRuleGroupsNamespace. You can't use this operation to
add tags to an existing rule groups namespace. Instead, use TagResource.
# Arguments
- `data`: The new rules file to use in the namespace. A base64-encoded version of the YAML
rule groups file. For details about the rule groups namespace structure, see
RuleGroupsNamespaceData.
- `name`: The name of the rule groups namespace that you are updating.
- `workspace_id`: The ID of the workspace where you are updating the rule groups namespace.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function put_rule_groups_namespace(
data, name, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)",
Dict{String,Any}("data" => data, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_rule_groups_namespace(
data,
name,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/rulegroupsnamespaces/$(name)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("data" => data, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
The TagResource operation associates tags with an Amazon Managed Service for Prometheus
resource. The only resources that can be tagged are workspaces and rule groups namespaces.
If you specify a new tag key for the resource, this tag is appended to the list of tags
associated with the resource. If you specify a tag key that is already associated with the
resource, the new tag value that you specify replaces the previous value for that tag.
# Arguments
- `resource_arn`: The ARN of the workspace or rule groups namespace to apply tags to.
- `tags`: The list of tag keys and values to associate with the resource. Keys may not
begin with aws:.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return amp(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the specified tags from an Amazon Managed Service for Prometheus resource. The only
resources that can be tagged are workspaces and rule groups namespaces.
# Arguments
- `resource_arn`: The ARN of the workspace or rule groups namespace.
- `tag_keys`: The keys of the tags to remove.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_logging_configuration(log_group_arn, workspace_id)
update_logging_configuration(log_group_arn, workspace_id, params::Dict{String,<:Any})
Updates the log group ARN or the workspace ID of the current logging configuration.
# Arguments
- `log_group_arn`: The ARN of the CloudWatch log group to which the vended log data will be
published.
- `workspace_id`: The ID of the workspace to update the logging configuration for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function update_logging_configuration(
logGroupArn, workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}("logGroupArn" => logGroupArn, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_logging_configuration(
logGroupArn,
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"PUT",
"/workspaces/$(workspaceId)/logging",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupArn" => logGroupArn, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_workspace_alias(workspace_id)
update_workspace_alias(workspace_id, params::Dict{String,<:Any})
Updates the alias of an existing workspace.
# Arguments
- `workspace_id`: The ID of the workspace to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: The new alias for the workspace. It does not need to be unique. Amazon Managed
Service for Prometheus will automatically strip any blank spaces from the beginning and end
of the alias that you specify.
- `"clientToken"`: A unique identifier that you can provide to ensure the idempotency of
the request. Case-sensitive.
"""
function update_workspace_alias(
workspaceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amp(
"POST",
"/workspaces/$(workspaceId)/alias",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_workspace_alias(
workspaceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amp(
"POST",
"/workspaces/$(workspaceId)/alias",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 51829 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: amplify
using AWS.Compat
using AWS.UUIDs
"""
create_app(name)
create_app(name, params::Dict{String,<:Any})
Creates a new Amplify app.
# Arguments
- `name`: The name of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accessToken"`: The personal access token for a GitHub repository for an Amplify app.
The personal access token is used to authorize access to a GitHub repository using the
Amplify GitHub App. The token is not stored. Use accessToken for GitHub repositories only.
To authorize access to a repository provider such as Bitbucket or CodeCommit, use
oauthToken. You must specify either accessToken or oauthToken when you create a new app.
Existing Amplify apps deployed from a GitHub repository using OAuth continue to work with
CI/CD. However, we strongly recommend that you migrate these apps to use the GitHub App.
For more information, see Migrating an existing OAuth app to the Amplify GitHub App in the
Amplify User Guide .
- `"autoBranchCreationConfig"`: The automated branch creation configuration for an Amplify
app.
- `"autoBranchCreationPatterns"`: The automated branch creation glob patterns for an
Amplify app.
- `"basicAuthCredentials"`: The credentials for basic authorization for an Amplify app. You
must base64-encode the authorization credentials and provide them in the format
user:password.
- `"buildSpec"`: The build specification (build spec) for an Amplify app.
- `"customHeaders"`: The custom HTTP headers for an Amplify app.
- `"customRules"`: The custom rewrite and redirect rules for an Amplify app.
- `"description"`: The description of the Amplify app.
- `"enableAutoBranchCreation"`: Enables automated branch creation for an Amplify app.
- `"enableBasicAuth"`: Enables basic authorization for an Amplify app. This will apply to
all branches that are part of this app.
- `"enableBranchAutoBuild"`: Enables the auto building of branches for an Amplify app.
- `"enableBranchAutoDeletion"`: Automatically disconnects a branch in the Amplify console
when you delete a branch from your Git repository.
- `"environmentVariables"`: The environment variables map for an Amplify app. For a list
of the environment variables that are accessible to Amplify by default, see Amplify
Environment variables in the Amplify Hosting User Guide.
- `"iamServiceRoleArn"`: The AWS Identity and Access Management (IAM) service role for an
Amplify app.
- `"oauthToken"`: The OAuth token for a third-party source control system for an Amplify
app. The OAuth token is used to create a webhook and a read-only deploy key using SSH
cloning. The OAuth token is not stored. Use oauthToken for repository providers other than
GitHub, such as Bitbucket or CodeCommit. To authorize access to GitHub as your repository
provider, use accessToken. You must specify either oauthToken or accessToken when you
create a new app. Existing Amplify apps deployed from a GitHub repository using OAuth
continue to work with CI/CD. However, we strongly recommend that you migrate these apps to
use the GitHub App. For more information, see Migrating an existing OAuth app to the
Amplify GitHub App in the Amplify User Guide .
- `"platform"`: The platform for the Amplify app. For a static app, set the platform type
to WEB. For a dynamic server-side rendered (SSR) app, set the platform type to WEB_COMPUTE.
For an app requiring Amplify Hosting's original SSR support only, set the platform type to
WEB_DYNAMIC.
- `"repository"`: The Git repository for the Amplify app.
- `"tags"`: The tag for an Amplify app.
"""
function create_app(name; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST",
"/apps",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend_environment(app_id, environment_name)
create_backend_environment(app_id, environment_name, params::Dict{String,<:Any})
Creates a new backend environment for an Amplify app. This API is available only to
Amplify Gen 1 applications where the backend is created using Amplify Studio or the Amplify
command line interface (CLI). This API isn’t available to Amplify Gen 2 applications.
When you deploy an application with Amplify Gen 2, you provision the app's backend
infrastructure using Typescript code.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `environment_name`: The name for the backend environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deploymentArtifacts"`: The name of deployment artifacts.
- `"stackName"`: The AWS CloudFormation stack name of a backend environment.
"""
function create_backend_environment(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/backendenvironments",
Dict{String,Any}("environmentName" => environmentName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend_environment(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/backendenvironments",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("environmentName" => environmentName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_branch(app_id, branch_name)
create_branch(app_id, branch_name, params::Dict{String,<:Any})
Creates a new branch for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name for the branch.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backend"`: The backend for a Branch of an Amplify app. Use for a backend created from
an CloudFormation stack. This field is available to Amplify Gen 2 apps only. When you
deploy an application with Amplify Gen 2, you provision the app's backend infrastructure
using Typescript code.
- `"backendEnvironmentArn"`: The Amazon Resource Name (ARN) for a backend environment that
is part of a Gen 1 Amplify app. This field is available to Amplify Gen 1 apps only where
the backend is created using Amplify Studio or the Amplify command line interface (CLI).
- `"basicAuthCredentials"`: The basic authorization credentials for the branch. You must
base64-encode the authorization credentials and provide them in the format user:password.
- `"buildSpec"`: The build specification (build spec) for the branch.
- `"description"`: The description for the branch.
- `"displayName"`: The display name for a branch. This is used as the default domain
prefix.
- `"enableAutoBuild"`: Enables auto building for the branch.
- `"enableBasicAuth"`: Enables basic authorization for the branch.
- `"enableNotification"`: Enables notifications for the branch.
- `"enablePerformanceMode"`: Enables performance mode for the branch. Performance mode
optimizes for faster hosting performance by keeping content cached at the edge for a longer
interval. When performance mode is enabled, hosting configuration or code changes can take
up to 10 minutes to roll out.
- `"enablePullRequestPreview"`: Enables pull request previews for this branch.
- `"environmentVariables"`: The environment variables for the branch.
- `"framework"`: The framework for the branch.
- `"pullRequestEnvironmentName"`: The Amplify environment name for the pull request.
- `"stage"`: Describes the current stage for the branch.
- `"tags"`: The tag for the branch.
- `"ttl"`: The content Time To Live (TTL) for the website in seconds.
"""
function create_branch(appId, branchName; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST",
"/apps/$(appId)/branches",
Dict{String,Any}("branchName" => branchName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_branch(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/branches",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("branchName" => branchName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment(app_id, branch_name)
create_deployment(app_id, branch_name, params::Dict{String,<:Any})
Creates a deployment for a manually deployed Amplify app. Manually deployed apps are not
connected to a repository. The maximum duration between the CreateDeployment call and the
StartDeployment call cannot exceed 8 hours. If the duration exceeds 8 hours, the
StartDeployment call and the associated Job will fail.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"fileMap"`: An optional file map that contains the file name as the key and the file
content md5 hash as the value. If this argument is provided, the service will generate a
unique upload URL per file. Otherwise, the service will only generate a single upload URL
for the zipped files.
"""
function create_deployment(
appId, branchName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain_association(app_id, domain_name, sub_domain_settings)
create_domain_association(app_id, domain_name, sub_domain_settings, params::Dict{String,<:Any})
Creates a new domain association for an Amplify app. This action associates a custom domain
with the Amplify app
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `domain_name`: The domain name for the domain association.
- `sub_domain_settings`: The setting for the subdomain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"autoSubDomainCreationPatterns"`: Sets the branch patterns for automatic subdomain
creation.
- `"autoSubDomainIAMRole"`: The required AWS Identity and Access Management (IAM) service
role for the Amazon Resource Name (ARN) for automatically creating subdomains.
- `"certificateSettings"`: The type of SSL/TLS certificate to use for your custom domain.
If you don't specify a certificate type, Amplify uses the default certificate that it
provisions and manages for you.
- `"enableAutoSubDomain"`: Enables the automated creation of subdomains for branches.
"""
function create_domain_association(
appId, domainName, subDomainSettings; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/domains",
Dict{String,Any}(
"domainName" => domainName, "subDomainSettings" => subDomainSettings
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain_association(
appId,
domainName,
subDomainSettings,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/domains",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domainName" => domainName, "subDomainSettings" => subDomainSettings
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_webhook(app_id, branch_name)
create_webhook(app_id, branch_name, params::Dict{String,<:Any})
Creates a new webhook on an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name for a branch that is part of an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description for a webhook.
"""
function create_webhook(
appId, branchName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/webhooks",
Dict{String,Any}("branchName" => branchName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_webhook(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/webhooks",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("branchName" => branchName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app(app_id)
delete_app(app_id, params::Dict{String,<:Any})
Deletes an existing Amplify app specified by an app ID.
# Arguments
- `app_id`: The unique ID for an Amplify app.
"""
function delete_app(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"DELETE", "/apps/$(appId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function delete_app(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/apps/$(appId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backend_environment(app_id, environment_name)
delete_backend_environment(app_id, environment_name, params::Dict{String,<:Any})
Deletes a backend environment for an Amplify app. This API is available only to Amplify
Gen 1 applications where the backend is created using Amplify Studio or the Amplify command
line interface (CLI). This API isn’t available to Amplify Gen 2 applications. When you
deploy an application with Amplify Gen 2, you provision the app's backend infrastructure
using Typescript code.
# Arguments
- `app_id`: The unique ID of an Amplify app.
- `environment_name`: The name of a backend environment of an Amplify app.
"""
function delete_backend_environment(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/apps/$(appId)/backendenvironments/$(environmentName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backend_environment(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/apps/$(appId)/backendenvironments/$(environmentName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_branch(app_id, branch_name)
delete_branch(app_id, branch_name, params::Dict{String,<:Any})
Deletes a branch for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch.
"""
function delete_branch(appId, branchName; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_branch(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain_association(app_id, domain_name)
delete_domain_association(app_id, domain_name, params::Dict{String,<:Any})
Deletes a domain association for an Amplify app.
# Arguments
- `app_id`: The unique id for an Amplify app.
- `domain_name`: The name of the domain.
"""
function delete_domain_association(
appId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/apps/$(appId)/domains/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain_association(
appId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/apps/$(appId)/domains/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_job(app_id, branch_name, job_id)
delete_job(app_id, branch_name, job_id, params::Dict{String,<:Any})
Deletes a job for a branch of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the job.
- `job_id`: The unique ID for the job.
"""
function delete_job(
appId, branchName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_job(
appId,
branchName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_webhook(webhook_id)
delete_webhook(webhook_id, params::Dict{String,<:Any})
Deletes a webhook.
# Arguments
- `webhook_id`: The unique ID for a webhook.
"""
function delete_webhook(webhookId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"DELETE",
"/webhooks/$(webhookId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_webhook(
webhookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/webhooks/$(webhookId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
generate_access_logs(app_id, domain_name)
generate_access_logs(app_id, domain_name, params::Dict{String,<:Any})
Returns the website access logs for a specific time range using a presigned URL.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `domain_name`: The name of the domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"endTime"`: The time at which the logs should end. The time range specified is inclusive
of the end time.
- `"startTime"`: The time at which the logs should start. The time range specified is
inclusive of the start time.
"""
function generate_access_logs(
appId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/accesslogs",
Dict{String,Any}("domainName" => domainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function generate_access_logs(
appId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/accesslogs",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("domainName" => domainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app(app_id)
get_app(app_id, params::Dict{String,<:Any})
Returns an existing Amplify app specified by an app ID.
# Arguments
- `app_id`: The unique ID for an Amplify app.
"""
function get_app(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET", "/apps/$(appId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_app(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_artifact_url(artifact_id)
get_artifact_url(artifact_id, params::Dict{String,<:Any})
Returns the artifact info that corresponds to an artifact id.
# Arguments
- `artifact_id`: The unique ID for an artifact.
"""
function get_artifact_url(artifactId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/artifacts/$(artifactId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_artifact_url(
artifactId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/artifacts/$(artifactId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_environment(app_id, environment_name)
get_backend_environment(app_id, environment_name, params::Dict{String,<:Any})
Returns a backend environment for an Amplify app. This API is available only to Amplify
Gen 1 applications where the backend is created using Amplify Studio or the Amplify command
line interface (CLI). This API isn’t available to Amplify Gen 2 applications. When you
deploy an application with Amplify Gen 2, you provision the app's backend infrastructure
using Typescript code.
# Arguments
- `app_id`: The unique id for an Amplify app.
- `environment_name`: The name for the backend environment.
"""
function get_backend_environment(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/backendenvironments/$(environmentName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_environment(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/backendenvironments/$(environmentName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_branch(app_id, branch_name)
get_branch(app_id, branch_name, params::Dict{String,<:Any})
Returns a branch for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch.
"""
function get_branch(appId, branchName; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_branch(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_association(app_id, domain_name)
get_domain_association(app_id, domain_name, params::Dict{String,<:Any})
Returns the domain information for an Amplify app.
# Arguments
- `app_id`: The unique id for an Amplify app.
- `domain_name`: The name of the domain.
"""
function get_domain_association(
appId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/domains/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_domain_association(
appId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/domains/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_job(app_id, branch_name, job_id)
get_job(app_id, branch_name, job_id, params::Dict{String,<:Any})
Returns a job for a branch of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the job.
- `job_id`: The unique ID for the job.
"""
function get_job(
appId, branchName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_job(
appId,
branchName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_webhook(webhook_id)
get_webhook(webhook_id, params::Dict{String,<:Any})
Returns the webhook information that corresponds to a specified webhook ID.
# Arguments
- `webhook_id`: The unique ID for a webhook.
"""
function get_webhook(webhookId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/webhooks/$(webhookId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_webhook(
webhookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/webhooks/$(webhookId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_apps()
list_apps(params::Dict{String,<:Any})
Returns a list of the existing Amplify apps.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. If non-null, the pagination token is returned in a
result. Pass its value in another request to retrieve more entries.
"""
function list_apps(; aws_config::AbstractAWSConfig=global_aws_config())
return amplify("GET", "/apps"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_apps(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET", "/apps", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_artifacts(app_id, branch_name, job_id)
list_artifacts(app_id, branch_name, job_id, params::Dict{String,<:Any})
Returns a list of artifacts for a specified app, branch, and job.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of a branch that is part of an Amplify app.
- `job_id`: The unique ID for a job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing artifacts from start. If
a non-null pagination token is returned in a result, pass its value in here to list more
artifacts.
"""
function list_artifacts(
appId, branchName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)/artifacts";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_artifacts(
appId,
branchName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)/artifacts",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backend_environments(app_id)
list_backend_environments(app_id, params::Dict{String,<:Any})
Lists the backend environments for an Amplify app. This API is available only to Amplify
Gen 1 applications where the backend is created using Amplify Studio or the Amplify command
line interface (CLI). This API isn’t available to Amplify Gen 2 applications. When you
deploy an application with Amplify Gen 2, you provision the app's backend infrastructure
using Typescript code.
# Arguments
- `app_id`: The unique ID for an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"environmentName"`: The name of the backend environment
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing backend environments from
the start. If a non-null pagination token is returned in a result, pass its value in here
to list more backend environments.
"""
function list_backend_environments(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/backendenvironments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backend_environments(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/backendenvironments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_branches(app_id)
list_branches(app_id, params::Dict{String,<:Any})
Lists the branches of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing branches from the start.
If a non-null pagination token is returned in a result, pass its value in here to list more
branches.
"""
function list_branches(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/branches";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_branches(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/branches",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_domain_associations(app_id)
list_domain_associations(app_id, params::Dict{String,<:Any})
Returns the domain associations for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing apps from the start. If
non-null, a pagination token is returned in a result. Pass its value in here to list more
projects.
"""
function list_domain_associations(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/domains";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_domain_associations(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/domains",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_jobs(app_id, branch_name)
list_jobs(app_id, branch_name, params::Dict{String,<:Any})
Lists the jobs for a branch of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing steps from the start. If
a non-null pagination token is returned in a result, pass its value in here to list more
steps.
"""
function list_jobs(appId, branchName; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_jobs(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/apps/$(appId)/branches/$(branchName)/jobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for a specified Amazon Resource Name (ARN).
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to list tags.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_webhooks(app_id)
list_webhooks(app_id, params::Dict{String,<:Any})
Returns a list of webhooks for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of records to list in a single response.
- `"nextToken"`: A pagination token. Set to null to start listing webhooks from the start.
If non-null,the pagination token is returned in a result. Pass its value in here to list
more webhooks.
"""
function list_webhooks(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"GET",
"/apps/$(appId)/webhooks";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_webhooks(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"GET",
"/apps/$(appId)/webhooks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_deployment(app_id, branch_name)
start_deployment(app_id, branch_name, params::Dict{String,<:Any})
Starts a deployment for a manually deployed app. Manually deployed apps are not connected
to a repository. The maximum duration between the CreateDeployment call and the
StartDeployment call cannot exceed 8 hours. If the duration exceeds 8 hours, the
StartDeployment call and the associated Job will fail.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobId"`: The job ID for this deployment, generated by the create deployment request.
- `"sourceUrl"`: The source URL for this deployment, used when calling start deployment
without create deployment. The source URL can be any HTTP GET URL that is publicly
accessible and downloads a single .zip file.
"""
function start_deployment(
appId, branchName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/deployments/start";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_deployment(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/deployments/start",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_job(app_id, branch_name, job_type)
start_job(app_id, branch_name, job_type, params::Dict{String,<:Any})
Starts a new job for a branch of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the job.
- `job_type`: Describes the type for the job. The job type RELEASE starts a new job with
the latest change from the specified branch. This value is available only for apps that are
connected to a repository. The job type RETRY retries an existing job. If the job type
value is RETRY, the jobId is also required.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitId"`: The commit ID from a third-party repository provider for the job.
- `"commitMessage"`: The commit message from a third-party repository provider for the
job.
- `"commitTime"`: The commit date and time for the job.
- `"jobId"`: The unique ID for an existing job. This is required if the value of jobType is
RETRY.
- `"jobReason"`: A descriptive reason for starting the job.
"""
function start_job(
appId, branchName, jobType; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/jobs",
Dict{String,Any}("jobType" => jobType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_job(
appId,
branchName,
jobType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)/jobs",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("jobType" => jobType), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_job(app_id, branch_name, job_id)
stop_job(app_id, branch_name, job_id, params::Dict{String,<:Any})
Stops a job that is in progress for a branch of an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch to use for the stop job request.
- `job_id`: The unique id for the job.
"""
function stop_job(
appId, branchName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)/stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_job(
appId,
branchName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/apps/$(appId)/branches/$(branchName)/jobs/$(jobId)/stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tags the resource with a tag key and value.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to tag a resource.
- `tags`: The tags used to tag the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Untags a resource with a specified Amazon Resource Name (ARN).
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to untag a resource.
- `tag_keys`: The tag keys to use to untag a resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app(app_id)
update_app(app_id, params::Dict{String,<:Any})
Updates an existing Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accessToken"`: The personal access token for a GitHub repository for an Amplify app.
The personal access token is used to authorize access to a GitHub repository using the
Amplify GitHub App. The token is not stored. Use accessToken for GitHub repositories only.
To authorize access to a repository provider such as Bitbucket or CodeCommit, use
oauthToken. You must specify either accessToken or oauthToken when you update an app.
Existing Amplify apps deployed from a GitHub repository using OAuth continue to work with
CI/CD. However, we strongly recommend that you migrate these apps to use the GitHub App.
For more information, see Migrating an existing OAuth app to the Amplify GitHub App in the
Amplify User Guide .
- `"autoBranchCreationConfig"`: The automated branch creation configuration for an Amplify
app.
- `"autoBranchCreationPatterns"`: Describes the automated branch creation glob patterns for
an Amplify app.
- `"basicAuthCredentials"`: The basic authorization credentials for an Amplify app. You
must base64-encode the authorization credentials and provide them in the format
user:password.
- `"buildSpec"`: The build specification (build spec) for an Amplify app.
- `"customHeaders"`: The custom HTTP headers for an Amplify app.
- `"customRules"`: The custom redirect and rewrite rules for an Amplify app.
- `"description"`: The description for an Amplify app.
- `"enableAutoBranchCreation"`: Enables automated branch creation for an Amplify app.
- `"enableBasicAuth"`: Enables basic authorization for an Amplify app.
- `"enableBranchAutoBuild"`: Enables branch auto-building for an Amplify app.
- `"enableBranchAutoDeletion"`: Automatically disconnects a branch in the Amplify console
when you delete a branch from your Git repository.
- `"environmentVariables"`: The environment variables for an Amplify app.
- `"iamServiceRoleArn"`: The AWS Identity and Access Management (IAM) service role for an
Amplify app.
- `"name"`: The name for an Amplify app.
- `"oauthToken"`: The OAuth token for a third-party source control system for an Amplify
app. The OAuth token is used to create a webhook and a read-only deploy key using SSH
cloning. The OAuth token is not stored. Use oauthToken for repository providers other than
GitHub, such as Bitbucket or CodeCommit. To authorize access to GitHub as your repository
provider, use accessToken. You must specify either oauthToken or accessToken when you
update an app. Existing Amplify apps deployed from a GitHub repository using OAuth continue
to work with CI/CD. However, we strongly recommend that you migrate these apps to use the
GitHub App. For more information, see Migrating an existing OAuth app to the Amplify GitHub
App in the Amplify User Guide .
- `"platform"`: The platform for the Amplify app. For a static app, set the platform type
to WEB. For a dynamic server-side rendered (SSR) app, set the platform type to WEB_COMPUTE.
For an app requiring Amplify Hosting's original SSR support only, set the platform type to
WEB_DYNAMIC.
- `"repository"`: The name of the Git repository for an Amplify app.
"""
function update_app(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST", "/apps/$(appId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_app(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_branch(app_id, branch_name)
update_branch(app_id, branch_name, params::Dict{String,<:Any})
Updates a branch for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `branch_name`: The name of the branch.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backend"`: The backend for a Branch of an Amplify app. Use for a backend created from
an CloudFormation stack. This field is available to Amplify Gen 2 apps only. When you
deploy an application with Amplify Gen 2, you provision the app's backend infrastructure
using Typescript code.
- `"backendEnvironmentArn"`: The Amazon Resource Name (ARN) for a backend environment that
is part of a Gen 1 Amplify app. This field is available to Amplify Gen 1 apps only where
the backend is created using Amplify Studio or the Amplify command line interface (CLI).
- `"basicAuthCredentials"`: The basic authorization credentials for the branch. You must
base64-encode the authorization credentials and provide them in the format user:password.
- `"buildSpec"`: The build specification (build spec) for the branch.
- `"description"`: The description for the branch.
- `"displayName"`: The display name for a branch. This is used as the default domain
prefix.
- `"enableAutoBuild"`: Enables auto building for the branch.
- `"enableBasicAuth"`: Enables basic authorization for the branch.
- `"enableNotification"`: Enables notifications for the branch.
- `"enablePerformanceMode"`: Enables performance mode for the branch. Performance mode
optimizes for faster hosting performance by keeping content cached at the edge for a longer
interval. When performance mode is enabled, hosting configuration or code changes can take
up to 10 minutes to roll out.
- `"enablePullRequestPreview"`: Enables pull request previews for this branch.
- `"environmentVariables"`: The environment variables for the branch.
- `"framework"`: The framework for the branch.
- `"pullRequestEnvironmentName"`: The Amplify environment name for the pull request.
- `"stage"`: Describes the current stage for the branch.
- `"ttl"`: The content Time to Live (TTL) for the website in seconds.
"""
function update_branch(appId, branchName; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_branch(
appId,
branchName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/branches/$(branchName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_domain_association(app_id, domain_name)
update_domain_association(app_id, domain_name, params::Dict{String,<:Any})
Creates a new domain association for an Amplify app.
# Arguments
- `app_id`: The unique ID for an Amplify app.
- `domain_name`: The name of the domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"autoSubDomainCreationPatterns"`: Sets the branch patterns for automatic subdomain
creation.
- `"autoSubDomainIAMRole"`: The required AWS Identity and Access Management (IAM) service
role for the Amazon Resource Name (ARN) for automatically creating subdomains.
- `"certificateSettings"`: The type of SSL/TLS certificate to use for your custom domain.
- `"enableAutoSubDomain"`: Enables the automated creation of subdomains for branches.
- `"subDomainSettings"`: Describes the settings for the subdomain.
"""
function update_domain_association(
appId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplify(
"POST",
"/apps/$(appId)/domains/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_domain_association(
appId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/apps/$(appId)/domains/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_webhook(webhook_id)
update_webhook(webhook_id, params::Dict{String,<:Any})
Updates a webhook.
# Arguments
- `webhook_id`: The unique ID for a webhook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"branchName"`: The name for a branch that is part of an Amplify app.
- `"description"`: The description for a webhook.
"""
function update_webhook(webhookId; aws_config::AbstractAWSConfig=global_aws_config())
return amplify(
"POST",
"/webhooks/$(webhookId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_webhook(
webhookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplify(
"POST",
"/webhooks/$(webhookId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 40020 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: amplifybackend
using AWS.Compat
using AWS.UUIDs
"""
clone_backend(app_id, backend_environment_name, target_environment_name)
clone_backend(app_id, backend_environment_name, target_environment_name, params::Dict{String,<:Any})
This operation clones an existing backend.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `target_environment_name`: The name of the destination backend environment to be created.
"""
function clone_backend(
appId,
backendEnvironmentName,
targetEnvironmentName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/environments/$(backendEnvironmentName)/clone",
Dict{String,Any}("targetEnvironmentName" => targetEnvironmentName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function clone_backend(
appId,
backendEnvironmentName,
targetEnvironmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/environments/$(backendEnvironmentName)/clone",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("targetEnvironmentName" => targetEnvironmentName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend(app_id, app_name, backend_environment_name)
create_backend(app_id, app_name, backend_environment_name, params::Dict{String,<:Any})
This operation creates a backend for an Amplify app. Backends are automatically created at
the time of app creation.
# Arguments
- `app_id`: The app ID.
- `app_name`: The name of the app.
- `backend_environment_name`: The name of the backend environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceConfig"`: The resource configuration for creating a backend.
- `"resourceName"`: The name of the resource.
"""
function create_backend(
appId,
appName,
backendEnvironmentName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend",
Dict{String,Any}(
"appId" => appId,
"appName" => appName,
"backendEnvironmentName" => backendEnvironmentName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend(
appId,
appName,
backendEnvironmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"appId" => appId,
"appName" => appName,
"backendEnvironmentName" => backendEnvironmentName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend_api(app_id, backend_environment_name, resource_config, resource_name)
create_backend_api(app_id, backend_environment_name, resource_config, resource_name, params::Dict{String,<:Any})
Creates a new backend API resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_config`: The resource configuration for this request.
- `resource_name`: The name of this resource.
"""
function create_backend_api(
appId,
backendEnvironmentName,
resourceConfig,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api",
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend_api(
appId,
backendEnvironmentName,
resourceConfig,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend_auth(app_id, backend_environment_name, resource_config, resource_name)
create_backend_auth(app_id, backend_environment_name, resource_config, resource_name, params::Dict{String,<:Any})
Creates a new backend authentication resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_config`: The resource configuration for this request object.
- `resource_name`: The name of this resource.
"""
function create_backend_auth(
appId,
backendEnvironmentName,
resourceConfig,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth",
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend_auth(
appId,
backendEnvironmentName,
resourceConfig,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend_config(app_id)
create_backend_config(app_id, params::Dict{String,<:Any})
Creates a config object for a backend.
# Arguments
- `app_id`: The app ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backendManagerAppId"`: The app ID for the backend manager.
"""
function create_backend_config(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend_config(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backend_storage(app_id, backend_environment_name, resource_config, resource_name)
create_backend_storage(app_id, backend_environment_name, resource_config, resource_name, params::Dict{String,<:Any})
Creates a backend storage resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_config`: The resource configuration for creating backend storage.
- `resource_name`: The name of the storage resource.
"""
function create_backend_storage(
appId,
backendEnvironmentName,
resourceConfig,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage",
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backend_storage(
appId,
backendEnvironmentName,
resourceConfig,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"backendEnvironmentName" => backendEnvironmentName,
"resourceConfig" => resourceConfig,
"resourceName" => resourceName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_token(app_id)
create_token(app_id, params::Dict{String,<:Any})
Generates a one-time challenge code to authenticate a user into your Amplify Admin UI.
# Arguments
- `app_id`: The app ID.
"""
function create_token(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/challenge";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_token(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/challenge",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backend(app_id, backend_environment_name)
delete_backend(app_id, backend_environment_name, params::Dict{String,<:Any})
Removes an existing environment from your Amplify project.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
"""
function delete_backend(
appId, backendEnvironmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/environments/$(backendEnvironmentName)/remove";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backend(
appId,
backendEnvironmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/environments/$(backendEnvironmentName)/remove",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backend_api(app_id, backend_environment_name, resource_name)
delete_backend_api(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Deletes an existing backend API resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceConfig"`: Defines the resource configuration for the data model in your Amplify
project.
"""
function delete_backend_api(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/remove",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backend_api(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/remove",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backend_auth(app_id, backend_environment_name, resource_name)
delete_backend_auth(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Deletes an existing backend authentication resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
"""
function delete_backend_auth(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/remove",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backend_auth(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/remove",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backend_storage(app_id, backend_environment_name, resource_name, service_name)
delete_backend_storage(app_id, backend_environment_name, resource_name, service_name, params::Dict{String,<:Any})
Removes the specified backend storage resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of the storage resource.
- `service_name`: The name of the storage service.
"""
function delete_backend_storage(
appId,
backendEnvironmentName,
resourceName,
serviceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/remove",
Dict{String,Any}("resourceName" => resourceName, "serviceName" => serviceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backend_storage(
appId,
backendEnvironmentName,
resourceName,
serviceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/remove",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"resourceName" => resourceName, "serviceName" => serviceName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_token(app_id, session_id)
delete_token(app_id, session_id, params::Dict{String,<:Any})
Deletes the challenge token based on the given appId and sessionId.
# Arguments
- `app_id`: The app ID.
- `session_id`: The session ID.
"""
function delete_token(appId, sessionId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/challenge/$(sessionId)/remove";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_token(
appId,
sessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/challenge/$(sessionId)/remove",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
generate_backend_apimodels(app_id, backend_environment_name, resource_name)
generate_backend_apimodels(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Generates a model schema for an existing backend API resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
"""
function generate_backend_apimodels(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/generateModels",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function generate_backend_apimodels(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/generateModels",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend(app_id)
get_backend(app_id, params::Dict{String,<:Any})
Provides project-level details for your Amplify UI project.
# Arguments
- `app_id`: The app ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backendEnvironmentName"`: The name of the backend environment.
"""
function get_backend(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/details";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/details",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_api(app_id, backend_environment_name, resource_name)
get_backend_api(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Gets the details for a backend API.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceConfig"`: Defines the resource configuration for the data model in your Amplify
project.
"""
function get_backend_api(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/details",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_api(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/details",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_apimodels(app_id, backend_environment_name, resource_name)
get_backend_apimodels(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Gets a model introspection schema for an existing backend API resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
"""
function get_backend_apimodels(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/getModels",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_apimodels(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)/getModels",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_auth(app_id, backend_environment_name, resource_name)
get_backend_auth(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Gets a backend auth details.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
"""
function get_backend_auth(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/details",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_auth(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/details",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_job(app_id, backend_environment_name, job_id)
get_backend_job(app_id, backend_environment_name, job_id, params::Dict{String,<:Any})
Returns information about a specific job.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `job_id`: The ID for the job.
"""
function get_backend_job(
appId, backendEnvironmentName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"GET",
"/backend/$(appId)/job/$(backendEnvironmentName)/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_job(
appId,
backendEnvironmentName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"GET",
"/backend/$(appId)/job/$(backendEnvironmentName)/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backend_storage(app_id, backend_environment_name, resource_name)
get_backend_storage(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Gets details for a backend storage resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of the storage resource.
"""
function get_backend_storage(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/details",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backend_storage(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/details",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_token(app_id, session_id)
get_token(app_id, session_id, params::Dict{String,<:Any})
Gets the challenge token based on the given appId and sessionId.
# Arguments
- `app_id`: The app ID.
- `session_id`: The session ID.
"""
function get_token(appId, sessionId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"GET",
"/backend/$(appId)/challenge/$(sessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_token(
appId,
sessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"GET",
"/backend/$(appId)/challenge/$(sessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_backend_auth(app_id, backend_environment_name, native_client_id, user_pool_id, web_client_id)
import_backend_auth(app_id, backend_environment_name, native_client_id, user_pool_id, web_client_id, params::Dict{String,<:Any})
Imports an existing backend authentication resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `native_client_id`: The ID of the Amazon Cognito native client.
- `user_pool_id`: The ID of the Amazon Cognito user pool.
- `web_client_id`: The ID of the Amazon Cognito web client.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"identityPoolId"`: The ID of the Amazon Cognito identity pool.
"""
function import_backend_auth(
appId,
backendEnvironmentName,
nativeClientId,
userPoolId,
webClientId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/import",
Dict{String,Any}(
"nativeClientId" => nativeClientId,
"userPoolId" => userPoolId,
"webClientId" => webClientId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_backend_auth(
appId,
backendEnvironmentName,
nativeClientId,
userPoolId,
webClientId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)/import",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"nativeClientId" => nativeClientId,
"userPoolId" => userPoolId,
"webClientId" => webClientId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_backend_storage(app_id, backend_environment_name, service_name)
import_backend_storage(app_id, backend_environment_name, service_name, params::Dict{String,<:Any})
Imports an existing backend storage resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `service_name`: The name of the storage service.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"bucketName"`: The name of the S3 bucket.
"""
function import_backend_storage(
appId,
backendEnvironmentName,
serviceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/import",
Dict{String,Any}("serviceName" => serviceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_backend_storage(
appId,
backendEnvironmentName,
serviceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)/import",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("serviceName" => serviceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backend_jobs(app_id, backend_environment_name)
list_backend_jobs(app_id, backend_environment_name, params::Dict{String,<:Any})
Lists the jobs for the backend of an Amplify app.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobId"`: The ID for the job.
- `"maxResults"`: The maximum number of results that you want in the response.
- `"nextToken"`: The token for the next set of results.
- `"operation"`: Filters the list of response objects to include only those with the
specified operation name.
- `"status"`: Filters the list of response objects to include only those with the specified
status.
"""
function list_backend_jobs(
appId, backendEnvironmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/job/$(backendEnvironmentName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backend_jobs(
appId,
backendEnvironmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/job/$(backendEnvironmentName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_s3_buckets()
list_s3_buckets(params::Dict{String,<:Any})
The list of S3 buckets in your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: Reserved for future use.
"""
function list_s3_buckets(; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST", "/s3Buckets"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_s3_buckets(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST", "/s3Buckets", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
remove_all_backends(app_id)
remove_all_backends(app_id, params::Dict{String,<:Any})
Removes all backend environments from your Amplify project.
# Arguments
- `app_id`: The app ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cleanAmplifyApp"`: Cleans up the Amplify Console app if this value is set to true.
"""
function remove_all_backends(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/remove";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_all_backends(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/remove",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_backend_config(app_id)
remove_backend_config(app_id, params::Dict{String,<:Any})
Removes the AWS resources required to access the Amplify Admin UI.
# Arguments
- `app_id`: The app ID.
"""
function remove_backend_config(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/config/remove";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_backend_config(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/config/remove",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backend_api(app_id, backend_environment_name, resource_name)
update_backend_api(app_id, backend_environment_name, resource_name, params::Dict{String,<:Any})
Updates an existing backend API resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_name`: The name of this resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceConfig"`: Defines the resource configuration for the data model in your Amplify
project.
"""
function update_backend_api(
appId,
backendEnvironmentName,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)",
Dict{String,Any}("resourceName" => resourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backend_api(
appId,
backendEnvironmentName,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/api/$(backendEnvironmentName)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceName" => resourceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backend_auth(app_id, backend_environment_name, resource_config, resource_name)
update_backend_auth(app_id, backend_environment_name, resource_config, resource_name, params::Dict{String,<:Any})
Updates an existing backend authentication resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_config`: The resource configuration for this request object.
- `resource_name`: The name of this resource.
"""
function update_backend_auth(
appId,
backendEnvironmentName,
resourceConfig,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)",
Dict{String,Any}(
"resourceConfig" => resourceConfig, "resourceName" => resourceName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backend_auth(
appId,
backendEnvironmentName,
resourceConfig,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/auth/$(backendEnvironmentName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"resourceConfig" => resourceConfig, "resourceName" => resourceName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backend_config(app_id)
update_backend_config(app_id, params::Dict{String,<:Any})
Updates the AWS resources required to access the Amplify Admin UI.
# Arguments
- `app_id`: The app ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"loginAuthConfig"`: Describes the Amazon Cognito configuration for Admin UI access.
"""
function update_backend_config(appId; aws_config::AbstractAWSConfig=global_aws_config())
return amplifybackend(
"POST",
"/backend/$(appId)/config/update";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backend_config(
appId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/config/update",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backend_job(app_id, backend_environment_name, job_id)
update_backend_job(app_id, backend_environment_name, job_id, params::Dict{String,<:Any})
Updates a specific job.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `job_id`: The ID for the job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"operation"`: Filters the list of response objects to include only those with the
specified operation name.
- `"status"`: Filters the list of response objects to include only those with the specified
status.
"""
function update_backend_job(
appId, backendEnvironmentName, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifybackend(
"POST",
"/backend/$(appId)/job/$(backendEnvironmentName)/$(jobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backend_job(
appId,
backendEnvironmentName,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/job/$(backendEnvironmentName)/$(jobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backend_storage(app_id, backend_environment_name, resource_config, resource_name)
update_backend_storage(app_id, backend_environment_name, resource_config, resource_name, params::Dict{String,<:Any})
Updates an existing backend storage resource.
# Arguments
- `app_id`: The app ID.
- `backend_environment_name`: The name of the backend environment.
- `resource_config`: The resource configuration for updating backend storage.
- `resource_name`: The name of the storage resource.
"""
function update_backend_storage(
appId,
backendEnvironmentName,
resourceConfig,
resourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)",
Dict{String,Any}(
"resourceConfig" => resourceConfig, "resourceName" => resourceName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backend_storage(
appId,
backendEnvironmentName,
resourceConfig,
resourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifybackend(
"POST",
"/backend/$(appId)/storage/$(backendEnvironmentName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"resourceConfig" => resourceConfig, "resourceName" => resourceName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 35784 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: amplifyuibuilder
using AWS.Compat
using AWS.UUIDs
"""
create_component(app_id, component_to_create, environment_name)
create_component(app_id, component_to_create, environment_name, params::Dict{String,<:Any})
Creates a new component for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app to associate with the component.
- `component_to_create`: Represents the configuration of the component to create.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function create_component(
appId,
componentToCreate,
environmentName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/components",
Dict{String,Any}(
"componentToCreate" => componentToCreate, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_component(
appId,
componentToCreate,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/components",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"componentToCreate" => componentToCreate,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_form(app_id, environment_name, form_to_create)
create_form(app_id, environment_name, form_to_create, params::Dict{String,<:Any})
Creates a new form for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app to associate with the form.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
- `form_to_create`: Represents the configuration of the form to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function create_form(
appId, environmentName, formToCreate; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/forms",
Dict{String,Any}("formToCreate" => formToCreate, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_form(
appId,
environmentName,
formToCreate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/forms",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"formToCreate" => formToCreate, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_theme(app_id, environment_name, theme_to_create)
create_theme(app_id, environment_name, theme_to_create, params::Dict{String,<:Any})
Creates a theme to apply to the components in an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app associated with the theme.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
- `theme_to_create`: Represents the configuration of the theme to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function create_theme(
appId, environmentName, themeToCreate; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/themes",
Dict{String,Any}(
"themeToCreate" => themeToCreate, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_theme(
appId,
environmentName,
themeToCreate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/themes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"themeToCreate" => themeToCreate, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_component(app_id, environment_name, id)
delete_component(app_id, environment_name, id, params::Dict{String,<:Any})
Deletes a component from an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app associated with the component to delete.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
- `id`: The unique ID of the component to delete.
"""
function delete_component(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/components/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_component(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/components/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_form(app_id, environment_name, id)
delete_form(app_id, environment_name, id, params::Dict{String,<:Any})
Deletes a form from an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app associated with the form to delete.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
- `id`: The unique ID of the form to delete.
"""
function delete_form(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_form(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_theme(app_id, environment_name, id)
delete_theme(app_id, environment_name, id, params::Dict{String,<:Any})
Deletes a theme from an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app associated with the theme to delete.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
- `id`: The unique ID of the theme to delete.
"""
function delete_theme(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_theme(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"DELETE",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
exchange_code_for_token(provider, request)
exchange_code_for_token(provider, request, params::Dict{String,<:Any})
This is for internal use. Amplify uses this action to exchange an access code for a token.
# Arguments
- `provider`: The third-party provider for the token. The only valid value is figma.
- `request`: Describes the configuration of the request.
"""
function exchange_code_for_token(
provider, request; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"POST",
"/tokens/$(provider)",
Dict{String,Any}("request" => request);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function exchange_code_for_token(
provider,
request,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/tokens/$(provider)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("request" => request), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_components(app_id, environment_name)
export_components(app_id, environment_name, params::Dict{String,<:Any})
Exports component configurations to code that is ready to integrate into an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app to export components to.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: The token to request the next page of results.
"""
function export_components(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/components";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_components(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/components",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_forms(app_id, environment_name)
export_forms(app_id, environment_name, params::Dict{String,<:Any})
Exports form configurations to code that is ready to integrate into an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app to export forms to.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: The token to request the next page of results.
"""
function export_forms(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/forms";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_forms(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/forms",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_themes(app_id, environment_name)
export_themes(app_id, environment_name, params::Dict{String,<:Any})
Exports theme configurations to code that is ready to integrate into an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app to export the themes to.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: The token to request the next page of results.
"""
function export_themes(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/themes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_themes(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/export/app/$(appId)/environment/$(environmentName)/themes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_codegen_job(app_id, environment_name, id)
get_codegen_job(app_id, environment_name, id, params::Dict{String,<:Any})
Returns an existing code generation job.
# Arguments
- `app_id`: The unique ID of the Amplify app associated with the code generation job.
- `environment_name`: The name of the backend environment that is a part of the Amplify app
associated with the code generation job.
- `id`: The unique ID of the code generation job.
"""
function get_codegen_job(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_codegen_job(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_component(app_id, environment_name, id)
get_component(app_id, environment_name, id, params::Dict{String,<:Any})
Returns an existing component for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID of the component.
"""
function get_component(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/components/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_component(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/components/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_form(app_id, environment_name, id)
get_form(app_id, environment_name, id, params::Dict{String,<:Any})
Returns an existing form for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID of the form.
"""
function get_form(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_form(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metadata(app_id, environment_name)
get_metadata(app_id, environment_name, params::Dict{String,<:Any})
Returns existing metadata for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
"""
function get_metadata(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/metadata";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metadata(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/metadata",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_theme(app_id, environment_name, id)
get_theme(app_id, environment_name, id, params::Dict{String,<:Any})
Returns an existing theme for an Amplify app.
# Arguments
- `app_id`: The unique ID of the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID for the theme.
"""
function get_theme(
appId, environmentName, id; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_theme(
appId,
environmentName,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_codegen_jobs(app_id, environment_name)
list_codegen_jobs(app_id, environment_name, params::Dict{String,<:Any})
Retrieves a list of code generation jobs for a specified Amplify app and backend
environment.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of jobs to retrieve.
- `"nextToken"`: The token to request the next page of results.
"""
function list_codegen_jobs(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_codegen_jobs(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_components(app_id, environment_name)
list_components(app_id, environment_name, params::Dict{String,<:Any})
Retrieves a list of components for a specified Amplify app and backend environment.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of components to retrieve.
- `"nextToken"`: The token to request the next page of results.
"""
function list_components(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/components";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_components(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/components",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_forms(app_id, environment_name)
list_forms(app_id, environment_name, params::Dict{String,<:Any})
Retrieves a list of forms for a specified Amplify app and backend environment.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of forms to retrieve.
- `"nextToken"`: The token to request the next page of results.
"""
function list_forms(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/forms";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_forms(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/forms",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for a specified Amazon Resource Name (ARN).
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to list tags.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_themes(app_id, environment_name)
list_themes(app_id, environment_name, params::Dict{String,<:Any})
Retrieves a list of themes for a specified Amplify app and backend environment.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of theme results to return in the response.
- `"nextToken"`: The token to request the next page of results.
"""
function list_themes(
appId, environmentName; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/themes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_themes(
appId,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"GET",
"/app/$(appId)/environment/$(environmentName)/themes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_metadata_flag(app_id, body, environment_name, feature_name)
put_metadata_flag(app_id, body, environment_name, feature_name, params::Dict{String,<:Any})
Stores the metadata information about a feature on a form.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `body`: The metadata information to store.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `feature_name`: The name of the feature associated with the metadata.
"""
function put_metadata_flag(
appId,
body,
environmentName,
featureName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PUT",
"/app/$(appId)/environment/$(environmentName)/metadata/features/$(featureName)",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_metadata_flag(
appId,
body,
environmentName,
featureName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PUT",
"/app/$(appId)/environment/$(environmentName)/metadata/features/$(featureName)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
refresh_token(provider, refresh_token_body)
refresh_token(provider, refresh_token_body, params::Dict{String,<:Any})
This is for internal use. Amplify uses this action to refresh a previously issued access
token that might have expired.
# Arguments
- `provider`: The third-party provider for the token. The only valid value is figma.
- `refresh_token_body`: Information about the refresh token request.
"""
function refresh_token(
provider, refreshTokenBody; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"POST",
"/tokens/$(provider)/refresh",
Dict{String,Any}("refreshTokenBody" => refreshTokenBody);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function refresh_token(
provider,
refreshTokenBody,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/tokens/$(provider)/refresh",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("refreshTokenBody" => refreshTokenBody), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_codegen_job(app_id, codegen_job_to_create, environment_name)
start_codegen_job(app_id, codegen_job_to_create, environment_name, params::Dict{String,<:Any})
Starts a code generation job for a specified Amplify app and backend environment.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `codegen_job_to_create`: The code generation job resource configuration.
- `environment_name`: The name of the backend environment that is a part of the Amplify app.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The idempotency token used to ensure that the code generation job
request completes only once.
"""
function start_codegen_job(
appId,
codegenJobToCreate,
environmentName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs",
Dict{String,Any}(
"codegenJobToCreate" => codegenJobToCreate, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_codegen_job(
appId,
codegenJobToCreate,
environmentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/app/$(appId)/environment/$(environmentName)/codegen-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"codegenJobToCreate" => codegenJobToCreate,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tags the resource with a tag key and value.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to tag a resource.
- `tags`: A list of tag key value pairs for a specified Amazon Resource Name (ARN).
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return amplifyuibuilder(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Untags a resource with a specified Amazon Resource Name (ARN).
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) to use to untag a resource.
- `tag_keys`: The tag keys to use to untag a resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return amplifyuibuilder(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_component(app_id, environment_name, id, updated_component)
update_component(app_id, environment_name, id, updated_component, params::Dict{String,<:Any})
Updates an existing component.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID for the component.
- `updated_component`: The configuration of the updated component.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function update_component(
appId,
environmentName,
id,
updatedComponent;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/components/$(id)",
Dict{String,Any}(
"updatedComponent" => updatedComponent, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_component(
appId,
environmentName,
id,
updatedComponent,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/components/$(id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"updatedComponent" => updatedComponent, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_form(app_id, environment_name, id, updated_form)
update_form(app_id, environment_name, id, updated_form, params::Dict{String,<:Any})
Updates an existing form.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID for the form.
- `updated_form`: The request accepts the following data in JSON format.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function update_form(
appId,
environmentName,
id,
updatedForm;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)",
Dict{String,Any}("updatedForm" => updatedForm, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_form(
appId,
environmentName,
id,
updatedForm,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/forms/$(id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"updatedForm" => updatedForm, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_theme(app_id, environment_name, id, updated_theme)
update_theme(app_id, environment_name, id, updated_theme, params::Dict{String,<:Any})
Updates an existing theme.
# Arguments
- `app_id`: The unique ID for the Amplify app.
- `environment_name`: The name of the backend environment that is part of the Amplify app.
- `id`: The unique ID for the theme.
- `updated_theme`: The configuration of the updated theme.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The unique client token.
"""
function update_theme(
appId,
environmentName,
id,
updatedTheme;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)",
Dict{String,Any}("updatedTheme" => updatedTheme, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_theme(
appId,
environmentName,
id,
updatedTheme,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return amplifyuibuilder(
"PATCH",
"/app/$(appId)/environment/$(environmentName)/themes/$(id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"updatedTheme" => updatedTheme, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 162118 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: api_gateway
using AWS.Compat
using AWS.UUIDs
"""
create_api_key()
create_api_key(params::Dict{String,<:Any})
Create an ApiKey resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"customerId"`: An Amazon Web Services Marketplace customer identifier, when integrating
with the Amazon Web Services SaaS Marketplace.
- `"description"`: The description of the ApiKey.
- `"enabled"`: Specifies whether the ApiKey can be used by callers.
- `"generateDistinctId"`: Specifies whether (true) or not (false) the key identifier is
distinct from the created API key value. This parameter is deprecated and should not be
used.
- `"name"`: The name of the ApiKey.
- `"stageKeys"`: DEPRECATED FOR USAGE PLANS - Specifies stages associated with the API key.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
- `"value"`: Specifies a value of the API key.
"""
function create_api_key(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST", "/apikeys"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function create_api_key(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST", "/apikeys", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
create_authorizer(name, restapi_id, type)
create_authorizer(name, restapi_id, type, params::Dict{String,<:Any})
Adds a new Authorizer resource to an existing RestApi resource.
# Arguments
- `name`: The name of the authorizer.
- `restapi_id`: The string identifier of the associated RestApi.
- `type`: The authorizer type. Valid values are TOKEN for a Lambda function using a single
authorization token submitted in a custom header, REQUEST for a Lambda function using
incoming request parameters, and COGNITO_USER_POOLS for using an Amazon Cognito user pool.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authType"`: Optional customer-defined field, used in OpenAPI imports and exports
without functional impact.
- `"authorizerCredentials"`: Specifies the required credentials as an IAM role for API
Gateway to invoke the authorizer. To specify an IAM role for API Gateway to assume, use the
role's Amazon Resource Name (ARN). To use resource-based permissions on the Lambda
function, specify null.
- `"authorizerResultTtlInSeconds"`: The TTL in seconds of cached authorizer results. If it
equals 0, authorization caching is disabled. If it is greater than 0, API Gateway will
cache authorizer responses. If this field is not set, the default value is 300. The maximum
value is 3600, or 1 hour.
- `"authorizerUri"`: Specifies the authorizer's Uniform Resource Identifier (URI). For
TOKEN or REQUEST authorizers, this must be a well-formed Lambda function URI, for example,
arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:{acco
unt_id}:function:{lambda_function_name}/invocations. In general, the URI has this form
arn:aws:apigateway:{region}:lambda:path/{service_api}, where {region} is the same as the
region hosting the Lambda function, path indicates that the remaining substring in the URI
should be treated as the path to the resource, including the initial /. For Lambda
functions, this is usually of the form /2015-03-31/functions/[FunctionARN]/invocations.
- `"identitySource"`: The identity source for which authorization is requested. For a TOKEN
or COGNITO_USER_POOLS authorizer, this is required and specifies the request header mapping
expression for the custom header holding the authorization token submitted by the client.
For example, if the token header name is Auth, the header mapping expression is
method.request.header.Auth. For the REQUEST authorizer, this is required when authorization
caching is enabled. The value is a comma-separated string of one or more mapping
expressions of the specified request parameters. For example, if an Auth header, a Name
query string parameter are defined as identity sources, this value is
method.request.header.Auth, method.request.querystring.Name. These parameters will be used
to derive the authorization caching key and to perform runtime validation of the REQUEST
authorizer by verifying all of the identity-related request parameters are present, not
null and non-empty. Only when this is true does the authorizer invoke the authorizer Lambda
function, otherwise, it returns a 401 Unauthorized response without calling the Lambda
function. The valid value is a string of comma-separated mapping expressions of the
specified request parameters. When the authorization caching is not enabled, this property
is optional.
- `"identityValidationExpression"`: A validation expression for the incoming identity
token. For TOKEN authorizers, this value is a regular expression. For COGNITO_USER_POOLS
authorizers, API Gateway will match the aud field of the incoming token from the client
against the specified regular expression. It will invoke the authorizer's Lambda function
when there is a match. Otherwise, it will return a 401 Unauthorized response without
calling the Lambda function. The validation expression does not apply to the REQUEST
authorizer.
- `"providerARNs"`: A list of the Amazon Cognito user pool ARNs for the COGNITO_USER_POOLS
authorizer. Each element is of this format:
arn:aws:cognito-idp:{region}:{account_id}:userpool/{user_pool_id}. For a TOKEN or REQUEST
authorizer, this is not defined.
"""
function create_authorizer(
name, restapi_id, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/authorizers",
Dict{String,Any}("name" => name, "type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_authorizer(
name,
restapi_id,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/authorizers",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("name" => name, "type" => type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_base_path_mapping(domain_name, rest_api_id)
create_base_path_mapping(domain_name, rest_api_id, params::Dict{String,<:Any})
Creates a new BasePathMapping resource.
# Arguments
- `domain_name`: The domain name of the BasePathMapping resource to create.
- `rest_api_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"basePath"`: The base path name that callers of the API must provide as part of the URL
after the domain name. This value must be unique for all of the mappings across a single
API. Specify '(none)' if you do not want callers to specify a base path name after the
domain name.
- `"stage"`: The name of the API's stage that you want to use for this mapping. Specify
'(none)' if you want callers to explicitly specify the stage name after any base path name.
"""
function create_base_path_mapping(
domain_name, restApiId; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/domainnames/$(domain_name)/basepathmappings",
Dict{String,Any}("restApiId" => restApiId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_base_path_mapping(
domain_name,
restApiId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/domainnames/$(domain_name)/basepathmappings",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("restApiId" => restApiId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment(restapi_id)
create_deployment(restapi_id, params::Dict{String,<:Any})
Creates a Deployment resource, which makes a specified RestApi callable over the internet.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cacheClusterEnabled"`: Enables a cache cluster for the Stage resource specified in the
input.
- `"cacheClusterSize"`: The stage's cache capacity in GB. For more information about
choosing a cache size, see Enabling API caching to enhance responsiveness.
- `"canarySettings"`: The input configuration for the canary deployment when the deployment
is a canary release deployment.
- `"description"`: The description for the Deployment resource to create.
- `"stageDescription"`: The description of the Stage resource for the Deployment resource
to create.
- `"stageName"`: The name of the Stage resource for the Deployment resource to create.
- `"tracingEnabled"`: Specifies whether active tracing with X-ray is enabled for the Stage.
- `"variables"`: A map that defines the stage variables for the Stage resource that is
associated with the new deployment. Variable names can have alphanumeric and underscore
characters, and the values must match [A-Za-z0-9-._~:/?#&=,]+.
"""
function create_deployment(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/restapis/$(restapi_id)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_documentation_part(location, properties, restapi_id)
create_documentation_part(location, properties, restapi_id, params::Dict{String,<:Any})
Creates a documentation part.
# Arguments
- `location`: The location of the targeted API entity of the to-be-created documentation
part.
- `properties`: The new documentation content map of the targeted API entity. Enclosed
key-value pairs are API-specific, but only OpenAPI-compliant key-value pairs can be
exported and, hence, published.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function create_documentation_part(
location, properties, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/documentation/parts",
Dict{String,Any}("location" => location, "properties" => properties);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_documentation_part(
location,
properties,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/documentation/parts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("location" => location, "properties" => properties),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_documentation_version(documentation_version, restapi_id)
create_documentation_version(documentation_version, restapi_id, params::Dict{String,<:Any})
Creates a documentation version
# Arguments
- `documentation_version`: The version identifier of the new snapshot.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description about the new documentation snapshot.
- `"stageName"`: The stage name to be associated with the new documentation snapshot.
"""
function create_documentation_version(
documentationVersion, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/documentation/versions",
Dict{String,Any}("documentationVersion" => documentationVersion);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_documentation_version(
documentationVersion,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/documentation/versions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("documentationVersion" => documentationVersion),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain_name(domain_name)
create_domain_name(domain_name, params::Dict{String,<:Any})
Creates a new domain name.
# Arguments
- `domain_name`: The name of the DomainName resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"certificateArn"`: The reference to an Amazon Web Services-managed certificate that will
be used by edge-optimized endpoint for this domain name. Certificate Manager is the only
supported source.
- `"certificateBody"`: [Deprecated] The body of the server certificate that will be used by
edge-optimized endpoint for this domain name provided by your certificate authority.
- `"certificateChain"`: [Deprecated] The intermediate certificates and optionally the root
certificate, one after the other without any blank lines, used by an edge-optimized
endpoint for this domain name. If you include the root certificate, your certificate chain
must start with intermediate certificates and end with the root certificate. Use the
intermediate certificates that were provided by your certificate authority. Do not include
any intermediaries that are not in the chain of trust path.
- `"certificateName"`: The user-friendly name of the certificate that will be used by
edge-optimized endpoint for this domain name.
- `"certificatePrivateKey"`: [Deprecated] Your edge-optimized endpoint's domain name
certificate's private key.
- `"endpointConfiguration"`: The endpoint configuration of this DomainName showing the
endpoint types of the domain name.
- `"mutualTlsAuthentication"`:
- `"ownershipVerificationCertificateArn"`: The ARN of the public certificate issued by ACM
to validate ownership of your custom domain. Only required when configuring mutual TLS and
using an ACM imported or private CA certificate ARN as the regionalCertificateArn.
- `"regionalCertificateArn"`: The reference to an Amazon Web Services-managed certificate
that will be used by regional endpoint for this domain name. Certificate Manager is the
only supported source.
- `"regionalCertificateName"`: The user-friendly name of the certificate that will be used
by regional endpoint for this domain name.
- `"securityPolicy"`: The Transport Layer Security (TLS) version + cipher suite for this
DomainName. The valid values are TLS_1_0 and TLS_1_2.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
"""
function create_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/domainnames",
Dict{String,Any}("domainName" => domainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/domainnames",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("domainName" => domainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_model(content_type, name, restapi_id)
create_model(content_type, name, restapi_id, params::Dict{String,<:Any})
Adds a new Model resource to an existing RestApi resource.
# Arguments
- `content_type`: The content-type for the model.
- `name`: The name of the model. Must be alphanumeric.
- `restapi_id`: The RestApi identifier under which the Model will be created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the model.
- `"schema"`: The schema for the model. For application/json models, this should be JSON
schema draft 4 model. The maximum size of the model is 400 KB.
"""
function create_model(
contentType, name, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/models",
Dict{String,Any}("contentType" => contentType, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_model(
contentType,
name,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/models",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("contentType" => contentType, "name" => name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_request_validator(restapi_id)
create_request_validator(restapi_id, params::Dict{String,<:Any})
Creates a RequestValidator of a given RestApi.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"name"`: The name of the to-be-created RequestValidator.
- `"validateRequestBody"`: A Boolean flag to indicate whether to validate request body
according to the configured model schema for the method (true) or not (false).
- `"validateRequestParameters"`: A Boolean flag to indicate whether to validate request
parameters, true, or not false.
"""
function create_request_validator(
restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/requestvalidators";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_request_validator(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/requestvalidators",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_resource(parent_id, path_part, restapi_id)
create_resource(parent_id, path_part, restapi_id, params::Dict{String,<:Any})
Creates a Resource resource.
# Arguments
- `parent_id`: The parent resource's identifier.
- `path_part`: The last path segment for this resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function create_resource(
parent_id, pathPart, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/resources/$(parent_id)",
Dict{String,Any}("pathPart" => pathPart);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_resource(
parent_id,
pathPart,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/resources/$(parent_id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pathPart" => pathPart), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_rest_api(name)
create_rest_api(name, params::Dict{String,<:Any})
Creates a new RestApi resource.
# Arguments
- `name`: The name of the RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeySource"`: The source of the API key for metering requests according to a usage
plan. Valid values are: HEADER to read the API key from the X-API-Key header of a request.
AUTHORIZER to read the API key from the UsageIdentifierKey from a custom authorizer.
- `"binaryMediaTypes"`: The list of binary media types supported by the RestApi. By
default, the RestApi supports only UTF-8-encoded text payloads.
- `"cloneFrom"`: The ID of the RestApi that you want to clone from.
- `"description"`: The description of the RestApi.
- `"disableExecuteApiEndpoint"`: Specifies whether clients can invoke your API by using the
default execute-api endpoint. By default, clients can invoke your API with the default
https://{api_id}.execute-api.{region}.amazonaws.com endpoint. To require that clients use a
custom domain name to invoke your API, disable the default endpoint
- `"endpointConfiguration"`: The endpoint configuration of this RestApi showing the
endpoint types of the API.
- `"minimumCompressionSize"`: A nullable integer that is used to enable compression (with
non-negative between 0 and 10485760 (10M) bytes, inclusive) or disable compression (with a
null value) on an API. When compression is enabled, compression or decompression is not
applied on the payload if the payload size is smaller than this value. Setting it to zero
allows compression for any payload size.
- `"policy"`: A stringified JSON policy document that applies to this RestApi regardless of
the caller and Method configuration.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
- `"version"`: A version identifier for the API.
"""
function create_rest_api(name; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/restapis",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_rest_api(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stage(deployment_id, restapi_id, stage_name)
create_stage(deployment_id, restapi_id, stage_name, params::Dict{String,<:Any})
Creates a new Stage resource that references a pre-existing Deployment for the API.
# Arguments
- `deployment_id`: The identifier of the Deployment resource for the Stage resource.
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name for the Stage resource. Stage names can only contain alphanumeric
characters, hyphens, and underscores. Maximum length is 128 characters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cacheClusterEnabled"`: Whether cache clustering is enabled for the stage.
- `"cacheClusterSize"`: The stage's cache capacity in GB. For more information about
choosing a cache size, see Enabling API caching to enhance responsiveness.
- `"canarySettings"`: The canary deployment settings of this stage.
- `"description"`: The description of the Stage resource.
- `"documentationVersion"`: The version of the associated API documentation.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
- `"tracingEnabled"`: Specifies whether active tracing with X-ray is enabled for the Stage.
- `"variables"`: A map that defines the stage variables for the new Stage resource.
Variable names can have alphanumeric and underscore characters, and the values must match
[A-Za-z0-9-._~:/?#&=,]+.
"""
function create_stage(
deploymentId, restapi_id, stageName; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/stages",
Dict{String,Any}("deploymentId" => deploymentId, "stageName" => stageName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stage(
deploymentId,
restapi_id,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/stages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentId" => deploymentId, "stageName" => stageName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_usage_plan(name)
create_usage_plan(name, params::Dict{String,<:Any})
Creates a usage plan with the throttle and quota limits, as well as the associated API
stages, specified in the payload.
# Arguments
- `name`: The name of the usage plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiStages"`: The associated API stages of the usage plan.
- `"description"`: The description of the usage plan.
- `"quota"`: The quota of the usage plan.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
- `"throttle"`: The throttling limits of the usage plan.
"""
function create_usage_plan(name; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/usageplans",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_usage_plan(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/usageplans",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_usage_plan_key(key_id, key_type, usageplan_id)
create_usage_plan_key(key_id, key_type, usageplan_id, params::Dict{String,<:Any})
Creates a usage plan key for adding an existing API key to a usage plan.
# Arguments
- `key_id`: The identifier of a UsagePlanKey resource for a plan customer.
- `key_type`: The type of a UsagePlanKey resource for a plan customer.
- `usageplan_id`: The Id of the UsagePlan resource representing the usage plan containing
the to-be-created UsagePlanKey resource representing a plan customer.
"""
function create_usage_plan_key(
keyId, keyType, usageplanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/usageplans/$(usageplanId)/keys",
Dict{String,Any}("keyId" => keyId, "keyType" => keyType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_usage_plan_key(
keyId,
keyType,
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/usageplans/$(usageplanId)/keys",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("keyId" => keyId, "keyType" => keyType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_vpc_link(name, target_arns)
create_vpc_link(name, target_arns, params::Dict{String,<:Any})
Creates a VPC link, under the caller's account in a selected region, in an asynchronous
operation that typically takes 2-4 minutes to complete and become operational. The caller
must have permissions to create and update VPC Endpoint services.
# Arguments
- `name`: The name used to label and identify the VPC link.
- `target_arns`: The ARN of the network load balancer of the VPC targeted by the VPC link.
The network load balancer must be owned by the same Amazon Web Services account of the API
owner.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the VPC link.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
"""
function create_vpc_link(
name, targetArns; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/vpclinks",
Dict{String,Any}("name" => name, "targetArns" => targetArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_vpc_link(
name,
targetArns,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/vpclinks",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("name" => name, "targetArns" => targetArns), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api_key(api__key)
delete_api_key(api__key, params::Dict{String,<:Any})
Deletes the ApiKey resource.
# Arguments
- `api__key`: The identifier of the ApiKey resource to be deleted.
"""
function delete_api_key(api_Key; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"DELETE",
"/apikeys/$(api_Key)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api_key(
api_Key, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/apikeys/$(api_Key)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_authorizer(authorizer_id, restapi_id)
delete_authorizer(authorizer_id, restapi_id, params::Dict{String,<:Any})
Deletes an existing Authorizer resource.
# Arguments
- `authorizer_id`: The identifier of the Authorizer resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_authorizer(
authorizer_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_authorizer(
authorizer_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_base_path_mapping(base_path, domain_name)
delete_base_path_mapping(base_path, domain_name, params::Dict{String,<:Any})
Deletes the BasePathMapping resource.
# Arguments
- `base_path`: The base path name of the BasePathMapping resource to delete. To specify an
empty base path, set this parameter to '(none)'.
- `domain_name`: The domain name of the BasePathMapping resource to delete.
"""
function delete_base_path_mapping(
base_path, domain_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_base_path_mapping(
base_path,
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_client_certificate(clientcertificate_id)
delete_client_certificate(clientcertificate_id, params::Dict{String,<:Any})
Deletes the ClientCertificate resource.
# Arguments
- `clientcertificate_id`: The identifier of the ClientCertificate resource to be deleted.
"""
function delete_client_certificate(
clientcertificate_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/clientcertificates/$(clientcertificate_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_client_certificate(
clientcertificate_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/clientcertificates/$(clientcertificate_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_deployment(deployment_id, restapi_id)
delete_deployment(deployment_id, restapi_id, params::Dict{String,<:Any})
Deletes a Deployment resource. Deleting a deployment will only succeed if there are no
Stage resources associated with it.
# Arguments
- `deployment_id`: The identifier of the Deployment resource to delete.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_deployment(
deployment_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/deployments/$(deployment_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_deployment(
deployment_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/deployments/$(deployment_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_documentation_part(part_id, restapi_id)
delete_documentation_part(part_id, restapi_id, params::Dict{String,<:Any})
Deletes a documentation part
# Arguments
- `part_id`: The identifier of the to-be-deleted documentation part.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_documentation_part(
part_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_documentation_part(
part_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_documentation_version(doc_version, restapi_id)
delete_documentation_version(doc_version, restapi_id, params::Dict{String,<:Any})
Deletes a documentation version.
# Arguments
- `doc_version`: The version identifier of a to-be-deleted documentation snapshot.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_documentation_version(
doc_version, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_documentation_version(
doc_version,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain_name(domain_name)
delete_domain_name(domain_name, params::Dict{String,<:Any})
Deletes the DomainName resource.
# Arguments
- `domain_name`: The name of the DomainName resource to be deleted.
"""
function delete_domain_name(domain_name; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"DELETE",
"/domainnames/$(domain_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain_name(
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/domainnames/$(domain_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_gateway_response(response_type, restapi_id)
delete_gateway_response(response_type, restapi_id, params::Dict{String,<:Any})
Clears any customization of a GatewayResponse of a specified response type on the given
RestApi and resets it with the default settings.
# Arguments
- `response_type`: The response type of the associated GatewayResponse.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_gateway_response(
response_type, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_gateway_response(
response_type,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_integration(http_method, resource_id, restapi_id)
delete_integration(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Represents a delete integration.
# Arguments
- `http_method`: Specifies a delete integration request's HTTP method.
- `resource_id`: Specifies a delete integration request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_integration(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_integration(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_integration_response(http_method, resource_id, restapi_id, status_code)
delete_integration_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Represents a delete integration response.
# Arguments
- `http_method`: Specifies a delete integration response request's HTTP method.
- `resource_id`: Specifies a delete integration response request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: Specifies a delete integration response request's status code.
"""
function delete_integration_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_integration_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_method(http_method, resource_id, restapi_id)
delete_method(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Deletes an existing Method resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the Method resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_method(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_method(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_method_response(http_method, resource_id, restapi_id, status_code)
delete_method_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Deletes an existing MethodResponse resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the MethodResponse resource.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: The status code identifier for the MethodResponse resource.
"""
function delete_method_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_method_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_model(model_name, restapi_id)
delete_model(model_name, restapi_id, params::Dict{String,<:Any})
Deletes a model.
# Arguments
- `model_name`: The name of the model to delete.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_model(
model_name, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/models/$(model_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_model(
model_name,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/models/$(model_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_request_validator(requestvalidator_id, restapi_id)
delete_request_validator(requestvalidator_id, restapi_id, params::Dict{String,<:Any})
Deletes a RequestValidator of a given RestApi.
# Arguments
- `requestvalidator_id`: The identifier of the RequestValidator to be deleted.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_request_validator(
requestvalidator_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_request_validator(
requestvalidator_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resource(resource_id, restapi_id)
delete_resource(resource_id, restapi_id, params::Dict{String,<:Any})
Deletes a Resource resource.
# Arguments
- `resource_id`: The identifier of the Resource resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_resource(
resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resource(
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/resources/$(resource_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_rest_api(restapi_id)
delete_rest_api(restapi_id, params::Dict{String,<:Any})
Deletes the specified API.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
"""
function delete_rest_api(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_rest_api(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stage(restapi_id, stage_name)
delete_stage(restapi_id, stage_name, params::Dict{String,<:Any})
Deletes a Stage resource.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the Stage resource to delete.
"""
function delete_stage(
restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stage(
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_usage_plan(usageplan_id)
delete_usage_plan(usageplan_id, params::Dict{String,<:Any})
Deletes a usage plan of a given plan Id.
# Arguments
- `usageplan_id`: The Id of the to-be-deleted usage plan.
"""
function delete_usage_plan(usageplanId; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"DELETE",
"/usageplans/$(usageplanId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_usage_plan(
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/usageplans/$(usageplanId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_usage_plan_key(key_id, usageplan_id)
delete_usage_plan_key(key_id, usageplan_id, params::Dict{String,<:Any})
Deletes a usage plan key and remove the underlying API key from the associated usage plan.
# Arguments
- `key_id`: The Id of the UsagePlanKey resource to be deleted.
- `usageplan_id`: The Id of the UsagePlan resource representing the usage plan containing
the to-be-deleted UsagePlanKey resource representing a plan customer.
"""
function delete_usage_plan_key(
keyId, usageplanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/usageplans/$(usageplanId)/keys/$(keyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_usage_plan_key(
keyId,
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/usageplans/$(usageplanId)/keys/$(keyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_vpc_link(vpclink_id)
delete_vpc_link(vpclink_id, params::Dict{String,<:Any})
Deletes an existing VpcLink of a specified identifier.
# Arguments
- `vpclink_id`: The identifier of the VpcLink. It is used in an Integration to reference
this VpcLink.
"""
function delete_vpc_link(vpclink_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"DELETE",
"/vpclinks/$(vpclink_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_vpc_link(
vpclink_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/vpclinks/$(vpclink_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
flush_stage_authorizers_cache(restapi_id, stage_name)
flush_stage_authorizers_cache(restapi_id, stage_name, params::Dict{String,<:Any})
Flushes all authorizer cache entries on a stage.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the stage to flush.
"""
function flush_stage_authorizers_cache(
restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)/cache/authorizers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function flush_stage_authorizers_cache(
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)/cache/authorizers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
flush_stage_cache(restapi_id, stage_name)
flush_stage_cache(restapi_id, stage_name, params::Dict{String,<:Any})
Flushes a stage's cache.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the stage to flush its cache.
"""
function flush_stage_cache(
restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)/cache/data";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function flush_stage_cache(
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/restapis/$(restapi_id)/stages/$(stage_name)/cache/data",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
generate_client_certificate()
generate_client_certificate(params::Dict{String,<:Any})
Generates a ClientCertificate resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the ClientCertificate.
- `"tags"`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The
tag key can be up to 128 characters and must not start with aws:. The tag value can be up
to 256 characters.
"""
function generate_client_certificate(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/clientcertificates";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function generate_client_certificate(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/clientcertificates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account()
get_account(params::Dict{String,<:Any})
Gets information about the current Account resource.
"""
function get_account(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/account"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/account", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_api_key(api__key)
get_api_key(api__key, params::Dict{String,<:Any})
Gets information about the current ApiKey resource.
# Arguments
- `api__key`: The identifier of the ApiKey resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeValue"`: A boolean flag to specify whether (true) or not (false) the result
contains the key value.
"""
function get_api_key(api_Key; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/apikeys/$(api_Key)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_api_key(
api_Key, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/apikeys/$(api_Key)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api_keys()
get_api_keys(params::Dict{String,<:Any})
Gets information about the current ApiKeys resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"customerId"`: The identifier of a customer in Amazon Web Services Marketplace or an
external system, such as a developer portal.
- `"includeValues"`: A boolean flag to specify whether (true) or not (false) the result
contains key values.
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"name"`: The name of queried API keys.
- `"position"`: The current pagination position in the paged result set.
"""
function get_api_keys(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/apikeys"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_api_keys(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/apikeys", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_authorizer(authorizer_id, restapi_id)
get_authorizer(authorizer_id, restapi_id, params::Dict{String,<:Any})
Describe an existing Authorizer resource.
# Arguments
- `authorizer_id`: The identifier of the Authorizer resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_authorizer(
authorizer_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_authorizer(
authorizer_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_authorizers(restapi_id)
get_authorizers(restapi_id, params::Dict{String,<:Any})
Describe an existing Authorizers resource.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_authorizers(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)/authorizers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_authorizers(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/authorizers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_base_path_mapping(base_path, domain_name)
get_base_path_mapping(base_path, domain_name, params::Dict{String,<:Any})
Describe a BasePathMapping resource.
# Arguments
- `base_path`: The base path name that callers of the API must provide as part of the URL
after the domain name. This value must be unique for all of the mappings across a single
API. Specify '(none)' if you do not want callers to specify any base path name after the
domain name.
- `domain_name`: The domain name of the BasePathMapping resource to be described.
"""
function get_base_path_mapping(
base_path, domain_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_base_path_mapping(
base_path,
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_base_path_mappings(domain_name)
get_base_path_mappings(domain_name, params::Dict{String,<:Any})
Represents a collection of BasePathMapping resources.
# Arguments
- `domain_name`: The domain name of a BasePathMapping resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_base_path_mappings(
domain_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/domainnames/$(domain_name)/basepathmappings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_base_path_mappings(
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/domainnames/$(domain_name)/basepathmappings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_client_certificate(clientcertificate_id)
get_client_certificate(clientcertificate_id, params::Dict{String,<:Any})
Gets information about the current ClientCertificate resource.
# Arguments
- `clientcertificate_id`: The identifier of the ClientCertificate resource to be described.
"""
function get_client_certificate(
clientcertificate_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/clientcertificates/$(clientcertificate_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_client_certificate(
clientcertificate_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/clientcertificates/$(clientcertificate_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_client_certificates()
get_client_certificates(params::Dict{String,<:Any})
Gets a collection of ClientCertificate resources.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_client_certificates(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/clientcertificates"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_client_certificates(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/clientcertificates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment(deployment_id, restapi_id)
get_deployment(deployment_id, restapi_id, params::Dict{String,<:Any})
Gets information about a Deployment resource.
# Arguments
- `deployment_id`: The identifier of the Deployment resource to get information about.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"embed"`: A query parameter to retrieve the specified embedded resources of the returned
Deployment resource in the response. In a REST API call, this embed parameter value is a
list of comma-separated strings, as in GET
/restapis/{restapi_id}/deployments/{deployment_id}?embed=var1,var2. The SDK and other
platform-dependent libraries might use a different format for the list. Currently, this
request supports only retrieval of the embedded API summary this way. Hence, the parameter
value must be a single-valued list containing only the \"apisummary\" string. For example,
GET /restapis/{restapi_id}/deployments/{deployment_id}?embed=apisummary.
"""
function get_deployment(
deployment_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/deployments/$(deployment_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment(
deployment_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/deployments/$(deployment_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployments(restapi_id)
get_deployments(restapi_id, params::Dict{String,<:Any})
Gets information about a Deployments collection.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_deployments(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployments(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_documentation_part(part_id, restapi_id)
get_documentation_part(part_id, restapi_id, params::Dict{String,<:Any})
Gets a documentation part.
# Arguments
- `part_id`: The string identifier of the associated RestApi.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_documentation_part(
part_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_documentation_part(
part_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_documentation_parts(restapi_id)
get_documentation_parts(restapi_id, params::Dict{String,<:Any})
Gets documentation parts.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"locationStatus"`: The status of the API documentation parts to retrieve. Valid values
are DOCUMENTED for retrieving DocumentationPart resources with content and UNDOCUMENTED for
DocumentationPart resources without content.
- `"name"`: The name of API entities of the to-be-retrieved documentation parts.
- `"path"`: The path of API entities of the to-be-retrieved documentation parts.
- `"position"`: The current pagination position in the paged result set.
- `"type"`: The type of API entities of the to-be-retrieved documentation parts.
"""
function get_documentation_parts(
restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/parts";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_documentation_parts(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/parts",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_documentation_version(doc_version, restapi_id)
get_documentation_version(doc_version, restapi_id, params::Dict{String,<:Any})
Gets a documentation version.
# Arguments
- `doc_version`: The version identifier of the to-be-retrieved documentation snapshot.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_documentation_version(
doc_version, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_documentation_version(
doc_version,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_documentation_versions(restapi_id)
get_documentation_versions(restapi_id, params::Dict{String,<:Any})
Gets documentation versions.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_documentation_versions(
restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/versions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_documentation_versions(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/documentation/versions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_name(domain_name)
get_domain_name(domain_name, params::Dict{String,<:Any})
Represents a domain name that is contained in a simpler, more intuitive URL that can be
called.
# Arguments
- `domain_name`: The name of the DomainName resource.
"""
function get_domain_name(domain_name; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/domainnames/$(domain_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_domain_name(
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/domainnames/$(domain_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_names()
get_domain_names(params::Dict{String,<:Any})
Represents a collection of DomainName resources.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_domain_names(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/domainnames"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_domain_names(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/domainnames",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_export(export_type, restapi_id, stage_name)
get_export(export_type, restapi_id, stage_name, params::Dict{String,<:Any})
Exports a deployed version of a RestApi in a specified format.
# Arguments
- `export_type`: The type of export. Acceptable values are 'oas30' for OpenAPI 3.0.x and
'swagger' for Swagger/OpenAPI 2.0.
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the Stage that will be exported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accept"`: The content-type of the export, for example application/json. Currently
application/json and application/yaml are supported for exportType ofoas30 and swagger.
This should be specified in the Accept header for direct API requests.
- `"parameters"`: A key-value map of query string parameters that specify properties of the
export, depending on the requested exportType. For exportType oas30 and swagger, any
combination of the following parameters are supported: extensions='integrations' or
extensions='apigateway' will export the API with x-amazon-apigateway-integration
extensions. extensions='authorizers' will export the API with
x-amazon-apigateway-authorizer extensions. postman will export the API with Postman
extensions, allowing for import to the Postman tool
"""
function get_export(
export_type, restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)/exports/$(export_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_export(
export_type,
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)/exports/$(export_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_gateway_response(response_type, restapi_id)
get_gateway_response(response_type, restapi_id, params::Dict{String,<:Any})
Gets a GatewayResponse of a specified response type on the given RestApi.
# Arguments
- `response_type`: The response type of the associated GatewayResponse.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_gateway_response(
response_type, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_gateway_response(
response_type,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_gateway_responses(restapi_id)
get_gateway_responses(restapi_id, params::Dict{String,<:Any})
Gets the GatewayResponses collection on the given RestApi. If an API developer has not
added any definitions for gateway responses, the result will be the API Gateway-generated
default GatewayResponses collection for the supported response types.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500. The GatewayResponses collection does not support pagination and
the limit does not apply here.
- `"position"`: The current pagination position in the paged result set. The
GatewayResponse collection does not support pagination and the position does not apply here.
"""
function get_gateway_responses(
restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/gatewayresponses";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_gateway_responses(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/gatewayresponses",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integration(http_method, resource_id, restapi_id)
get_integration(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Get the integration settings.
# Arguments
- `http_method`: Specifies a get integration request's HTTP method.
- `resource_id`: Specifies a get integration request's resource identifier
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_integration(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integration(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integration_response(http_method, resource_id, restapi_id, status_code)
get_integration_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Represents a get integration response.
# Arguments
- `http_method`: Specifies a get integration response request's HTTP method.
- `resource_id`: Specifies a get integration response request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: Specifies a get integration response request's status code.
"""
function get_integration_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integration_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_method(http_method, resource_id, restapi_id)
get_method(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Describe an existing Method resource.
# Arguments
- `http_method`: Specifies the method request's HTTP method type.
- `resource_id`: The Resource identifier for the Method resource.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_method(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_method(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_method_response(http_method, resource_id, restapi_id, status_code)
get_method_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Describes a MethodResponse resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the MethodResponse resource.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: The status code for the MethodResponse resource.
"""
function get_method_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_method_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model(model_name, restapi_id)
get_model(model_name, restapi_id, params::Dict{String,<:Any})
Describes an existing model defined for a RestApi resource.
# Arguments
- `model_name`: The name of the model as an identifier.
- `restapi_id`: The RestApi identifier under which the Model exists.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"flatten"`: A query parameter of a Boolean value to resolve (true) all external model
references and returns a flattened model schema or not (false) The default is false.
"""
function get_model(
model_name, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models/$(model_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model(
model_name,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models/$(model_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model_template(model_name, restapi_id)
get_model_template(model_name, restapi_id, params::Dict{String,<:Any})
Generates a sample mapping template that can be used to transform a payload into the
structure of a model.
# Arguments
- `model_name`: The name of the model for which to generate a template.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_model_template(
model_name, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models/$(model_name)/default_template";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model_template(
model_name,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models/$(model_name)/default_template",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_models(restapi_id)
get_models(restapi_id, params::Dict{String,<:Any})
Describes existing Models defined for a RestApi resource.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_models(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_models(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/models",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_request_validator(requestvalidator_id, restapi_id)
get_request_validator(requestvalidator_id, restapi_id, params::Dict{String,<:Any})
Gets a RequestValidator of a given RestApi.
# Arguments
- `requestvalidator_id`: The identifier of the RequestValidator to be retrieved.
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_request_validator(
requestvalidator_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_request_validator(
requestvalidator_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_request_validators(restapi_id)
get_request_validators(restapi_id, params::Dict{String,<:Any})
Gets the RequestValidators collection of a given RestApi.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_request_validators(
restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/requestvalidators";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_request_validators(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/requestvalidators",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource(resource_id, restapi_id)
get_resource(resource_id, restapi_id, params::Dict{String,<:Any})
Lists information about a resource.
# Arguments
- `resource_id`: The identifier for the Resource resource.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"embed"`: A query parameter to retrieve the specified resources embedded in the returned
Resource representation in the response. This embed parameter value is a list of
comma-separated strings. Currently, the request supports only retrieval of the embedded
Method resources this way. The query parameter value must be a single-valued list and
contain the \"methods\" string. For example, GET
/restapis/{restapi_id}/resources/{resource_id}?embed=methods.
"""
function get_resource(
resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource(
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources/$(resource_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resources(restapi_id)
get_resources(restapi_id, params::Dict{String,<:Any})
Lists information about a collection of Resource resources.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"embed"`: A query parameter used to retrieve the specified resources embedded in the
returned Resources resource in the response. This embed parameter value is a list of
comma-separated strings. Currently, the request supports only retrieval of the embedded
Method resources this way. The query parameter value must be a single-valued list and
contain the \"methods\" string. For example, GET
/restapis/{restapi_id}/resources?embed=methods.
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_resources(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resources(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/resources",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_rest_api(restapi_id)
get_rest_api(restapi_id, params::Dict{String,<:Any})
Lists the RestApi resource in the collection.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
"""
function get_rest_api(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_rest_api(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_rest_apis()
get_rest_apis(params::Dict{String,<:Any})
Lists the RestApis resources for your collection.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_rest_apis(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/restapis"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_rest_apis(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/restapis", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_sdk(restapi_id, sdk_type, stage_name)
get_sdk(restapi_id, sdk_type, stage_name, params::Dict{String,<:Any})
Generates a client SDK for a RestApi and Stage.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `sdk_type`: The language for the generated SDK. Currently java, javascript, android,
objectivec (for iOS), swift (for iOS), and ruby are supported.
- `stage_name`: The name of the Stage that the SDK will use.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"parameters"`: A string-to-string key-value map of query parameters sdkType-dependent
properties of the SDK. For sdkType of objectivec or swift, a parameter named classPrefix is
required. For sdkType of android, parameters named groupId, artifactId, artifactVersion,
and invokerPackage are required. For sdkType of java, parameters named serviceName and
javaPackageName are required.
"""
function get_sdk(
restapi_id, sdk_type, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)/sdks/$(sdk_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sdk(
restapi_id,
sdk_type,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)/sdks/$(sdk_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sdk_type(sdktype_id)
get_sdk_type(sdktype_id, params::Dict{String,<:Any})
Gets an SDK type.
# Arguments
- `sdktype_id`: The identifier of the queried SdkType instance.
"""
function get_sdk_type(sdktype_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/sdktypes/$(sdktype_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sdk_type(
sdktype_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/sdktypes/$(sdktype_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sdk_types()
get_sdk_types(params::Dict{String,<:Any})
Gets SDK types
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_sdk_types(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/sdktypes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_sdk_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/sdktypes", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_stage(restapi_id, stage_name)
get_stage(restapi_id, stage_name, params::Dict{String,<:Any})
Gets information about a Stage resource.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the Stage resource to get information about.
"""
function get_stage(
restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_stage(
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages/$(stage_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_stages(restapi_id)
get_stages(restapi_id, params::Dict{String,<:Any})
Gets information about one or more Stage resources.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deploymentId"`: The stages' deployment identifiers.
"""
function get_stages(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_stages(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/restapis/$(restapi_id)/stages",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_tags(resource_arn)
get_tags(resource_arn, params::Dict{String,<:Any})
Gets the Tags collection for a given resource.
# Arguments
- `resource_arn`: The ARN of a resource that can be tagged.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: (Not currently supported) The maximum number of returned results per page. The
default value is 25 and the maximum value is 500.
- `"position"`: (Not currently supported) The current pagination position in the paged
result set.
"""
function get_tags(resource_arn; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/tags/$(resource_arn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_tags(
resource_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/tags/$(resource_arn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_usage(end_date, start_date, usageplan_id)
get_usage(end_date, start_date, usageplan_id, params::Dict{String,<:Any})
Gets the usage data of a usage plan in a specified time interval.
# Arguments
- `end_date`: The ending date (e.g., 2016-12-31) of the usage data.
- `start_date`: The starting date (e.g., 2016-01-01) of the usage data.
- `usageplan_id`: The Id of the usage plan associated with the usage data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"keyId"`: The Id of the API key associated with the resultant usage data.
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_usage(
endDate, startDate, usageplanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/usage",
Dict{String,Any}("endDate" => endDate, "startDate" => startDate);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_usage(
endDate,
startDate,
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/usage",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("endDate" => endDate, "startDate" => startDate),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_usage_plan(usageplan_id)
get_usage_plan(usageplan_id, params::Dict{String,<:Any})
Gets a usage plan of a given plan identifier.
# Arguments
- `usageplan_id`: The identifier of the UsagePlan resource to be retrieved.
"""
function get_usage_plan(usageplanId; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/usageplans/$(usageplanId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_usage_plan(
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_usage_plan_key(key_id, usageplan_id)
get_usage_plan_key(key_id, usageplan_id, params::Dict{String,<:Any})
Gets a usage plan key of a given key identifier.
# Arguments
- `key_id`: The key Id of the to-be-retrieved UsagePlanKey resource representing a plan
customer.
- `usageplan_id`: The Id of the UsagePlan resource representing the usage plan containing
the to-be-retrieved UsagePlanKey resource representing a plan customer.
"""
function get_usage_plan_key(
keyId, usageplanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/keys/$(keyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_usage_plan_key(
keyId,
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/keys/$(keyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_usage_plan_keys(usageplan_id)
get_usage_plan_keys(usageplan_id, params::Dict{String,<:Any})
Gets all the usage plan keys representing the API keys added to a specified usage plan.
# Arguments
- `usageplan_id`: The Id of the UsagePlan resource representing the usage plan containing
the to-be-retrieved UsagePlanKey resource representing a plan customer.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"name"`: A query parameter specifying the name of the to-be-returned usage plan keys.
- `"position"`: The current pagination position in the paged result set.
"""
function get_usage_plan_keys(usageplanId; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/keys";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_usage_plan_keys(
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/usageplans/$(usageplanId)/keys",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_usage_plans()
get_usage_plans(params::Dict{String,<:Any})
Gets all the usage plans of the caller's account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"keyId"`: The identifier of the API key associated with the usage plans.
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_usage_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/usageplans"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_usage_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/usageplans", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_vpc_link(vpclink_id)
get_vpc_link(vpclink_id, params::Dict{String,<:Any})
Gets a specified VPC link under the caller's account in a region.
# Arguments
- `vpclink_id`: The identifier of the VpcLink. It is used in an Integration to reference
this VpcLink.
"""
function get_vpc_link(vpclink_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET",
"/vpclinks/$(vpclink_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_vpc_link(
vpclink_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"GET",
"/vpclinks/$(vpclink_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_vpc_links()
get_vpc_links(params::Dict{String,<:Any})
Gets the VpcLinks collection under the caller's account in a selected region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of returned results per page. The default value is 25 and
the maximum value is 500.
- `"position"`: The current pagination position in the paged result set.
"""
function get_vpc_links(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"GET", "/vpclinks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_vpc_links(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"GET", "/vpclinks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
import_api_keys(body, format)
import_api_keys(body, format, params::Dict{String,<:Any})
Import API keys from an external source, such as a CSV-formatted file.
# Arguments
- `body`: The payload of the POST request to import API keys. For the payload format, see
API Key File Format.
- `format`: A query parameter to specify the input format to imported API keys. Currently,
only the csv format is supported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"failonwarnings"`: A query parameter to indicate whether to rollback ApiKey importation
(true) or not (false) when error is encountered.
"""
function import_api_keys(body, format; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/apikeys?mode=import",
Dict{String,Any}("body" => body, "format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_api_keys(
body,
format,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/apikeys?mode=import",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("body" => body, "format" => format), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_documentation_parts(body, restapi_id)
import_documentation_parts(body, restapi_id, params::Dict{String,<:Any})
Imports documentation parts
# Arguments
- `body`: Raw byte array representing the to-be-imported documentation parts. To import
from an OpenAPI file, this is a JSON object.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"failonwarnings"`: A query parameter to specify whether to rollback the documentation
importation (true) or not (false) when a warning is encountered. The default value is false.
- `"mode"`: A query parameter to indicate whether to overwrite (overwrite) any existing
DocumentationParts definition or to merge (merge) the new definition into the existing one.
The default value is merge.
"""
function import_documentation_parts(
body, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/documentation/parts",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_documentation_parts(
body,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/documentation/parts",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_rest_api(body)
import_rest_api(body, params::Dict{String,<:Any})
A feature of the API Gateway control service for creating a new API from an external API
definition file.
# Arguments
- `body`: The POST request body containing external API definitions. Currently, only
OpenAPI definition JSON/YAML files are supported. The maximum size of the API definition
file is 6MB.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"failonwarnings"`: A query parameter to indicate whether to rollback the API creation
(true) or not (false) when a warning is encountered. The default value is false.
- `"parameters"`: A key-value map of context-specific query string parameters specifying
the behavior of different API importing operations. The following shows operation-specific
parameters and their supported values. To exclude DocumentationParts from the import, set
parameters as ignore=documentation. To configure the endpoint type, set parameters as
endpointConfigurationTypes=EDGE, endpointConfigurationTypes=REGIONAL, or
endpointConfigurationTypes=PRIVATE. The default endpoint type is EDGE. To handle imported
basepath, set parameters as basepath=ignore, basepath=prepend or basepath=split.
"""
function import_rest_api(body; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"POST",
"/restapis?mode=import",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_rest_api(
body, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis?mode=import",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_gateway_response(response_type, restapi_id)
put_gateway_response(response_type, restapi_id, params::Dict{String,<:Any})
Creates a customization of a GatewayResponse of a specified response type and status code
on the given RestApi.
# Arguments
- `response_type`: The response type of the associated GatewayResponse
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"responseParameters"`: Response parameters (paths, query strings and headers) of the
GatewayResponse as a string-to-string map of key-value pairs.
- `"responseTemplates"`: Response templates of the GatewayResponse as a string-to-string
map of key-value pairs.
- `"statusCode"`: The HTTP status code of the GatewayResponse.
"""
function put_gateway_response(
response_type, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_gateway_response(
response_type,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_integration(http_method, resource_id, restapi_id, type)
put_integration(http_method, resource_id, restapi_id, type, params::Dict{String,<:Any})
Sets up a method's integration.
# Arguments
- `http_method`: Specifies the HTTP method for the integration.
- `resource_id`: Specifies a put integration request's resource ID.
- `restapi_id`: The string identifier of the associated RestApi.
- `type`: Specifies a put integration input's type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cacheKeyParameters"`: A list of request parameters whose values API Gateway caches. To
be valid values for cacheKeyParameters, these parameters must also be specified for Method
requestParameters.
- `"cacheNamespace"`: Specifies a group of related cached parameters. By default, API
Gateway uses the resource ID as the cacheNamespace. You can specify the same cacheNamespace
across resources to return the same cached data for requests to different resources.
- `"connectionId"`: The ID of the VpcLink used for the integration. Specify this value only
if you specify VPC_LINK as the connection type.
- `"connectionType"`: The type of the network connection to the integration endpoint. The
valid value is INTERNET for connections through the public routable internet or VPC_LINK
for private connections between API Gateway and a network load balancer in a VPC. The
default value is INTERNET.
- `"contentHandling"`: Specifies how to handle request payload content type conversions.
Supported values are CONVERT_TO_BINARY and CONVERT_TO_TEXT, with the following behaviors:
If this property is not defined, the request payload will be passed through from the method
request to integration request without modification, provided that the passthroughBehavior
is configured to support payload pass-through.
- `"credentials"`: Specifies whether credentials are required for a put integration.
- `"httpMethod"`: The HTTP method for the integration.
- `"passthroughBehavior"`: Specifies the pass-through behavior for incoming requests based
on the Content-Type header in the request, and the available mapping templates specified as
the requestTemplates property on the Integration resource. There are three valid values:
WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and NEVER.
- `"requestParameters"`: A key-value map specifying request parameters that are passed from
the method request to the back end. The key is an integration request parameter name and
the associated value is a method request parameter value or static value that must be
enclosed within single quotes and pre-encoded as required by the back end. The method
request parameter value must match the pattern of method.request.{location}.{name}, where
location is querystring, path, or header and name must be a valid and unique method request
parameter name.
- `"requestTemplates"`: Represents a map of Velocity templates that are applied on the
request payload based on the value of the Content-Type header sent by the client. The
content type value is the key in this map, and the template (as a String) is the value.
- `"timeoutInMillis"`: Custom timeout between 50 and 29,000 milliseconds. The default value
is 29,000 milliseconds or 29 seconds.
- `"tlsConfig"`:
- `"uri"`: Specifies Uniform Resource Identifier (URI) of the integration endpoint. For
HTTP or HTTP_PROXY integrations, the URI must be a fully formed, encoded HTTP(S) URL
according to the RFC-3986 specification, for either standard integration, where
connectionType is not VPC_LINK, or private integration, where connectionType is VPC_LINK.
For a private HTTP integration, the URI is not used for routing. For AWS or AWS_PROXY
integrations, the URI is of the form
arn:aws:apigateway:{region}:{subdomain.service|service}:path|action/{service_api}. Here,
{Region} is the API Gateway region (e.g., us-east-1); {service} is the name of the
integrated Amazon Web Services service (e.g., s3); and {subdomain} is a designated
subdomain supported by certain Amazon Web Services service for fast host-name lookup.
action can be used for an Amazon Web Services service action-based API, using an
Action={name}&{p1}={v1}&p2={v2}... query string. The ensuing {service_api} refers
to a supported action {name} plus any required input parameters. Alternatively, path can be
used for an Amazon Web Services service path-based API. The ensuing service_api refers to
the path to an Amazon Web Services service resource, including the region of the integrated
Amazon Web Services service, if applicable. For example, for integration with the S3 API of
GetObject, the uri can be either
arn:aws:apigateway:us-west-2:s3:action/GetObject&Bucket={bucket}&Key={key} or
arn:aws:apigateway:us-west-2:s3:path/{bucket}/{key}.
"""
function put_integration(
http_method,
resource_id,
restapi_id,
type;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration",
Dict{String,Any}("type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_integration(
http_method,
resource_id,
restapi_id,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("type" => type), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_integration_response(http_method, resource_id, restapi_id, status_code)
put_integration_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Represents a put integration.
# Arguments
- `http_method`: Specifies a put integration response request's HTTP method.
- `resource_id`: Specifies a put integration response request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: Specifies the status code that is used to map the integration response to
an existing MethodResponse.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentHandling"`: Specifies how to handle response payload content type conversions.
Supported values are CONVERT_TO_BINARY and CONVERT_TO_TEXT, with the following behaviors:
If this property is not defined, the response payload will be passed through from the
integration response to the method response without modification.
- `"responseParameters"`: A key-value map specifying response parameters that are passed to
the method response from the back end. The key is a method response header parameter name
and the mapped value is an integration response header value, a static value enclosed
within a pair of single quotes, or a JSON expression from the integration response body.
The mapping key must match the pattern of method.response.header.{name}, where name is a
valid and unique header name. The mapped non-static value must match the pattern of
integration.response.header.{name} or integration.response.body.{JSON-expression}, where
name must be a valid and unique response header name and JSON-expression a valid JSON
expression without the prefix.
- `"responseTemplates"`: Specifies a put integration response's templates.
- `"selectionPattern"`: Specifies the selection pattern of a put integration response.
"""
function put_integration_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_integration_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_method(authorization_type, http_method, resource_id, restapi_id)
put_method(authorization_type, http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Add a method to an existing Resource resource.
# Arguments
- `authorization_type`: The method's authorization type. Valid values are NONE for open
access, AWS_IAM for using AWS IAM permissions, CUSTOM for using a custom authorizer, or
COGNITO_USER_POOLS for using a Cognito user pool.
- `http_method`: Specifies the method request's HTTP method type.
- `resource_id`: The Resource identifier for the new Method resource.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeyRequired"`: Specifies whether the method required a valid ApiKey.
- `"authorizationScopes"`: A list of authorization scopes configured on the method. The
scopes are used with a COGNITO_USER_POOLS authorizer to authorize the method invocation.
The authorization works by matching the method scopes against the scopes parsed from the
access token in the incoming request. The method invocation is authorized if any method
scopes matches a claimed scope in the access token. Otherwise, the invocation is not
authorized. When the method scope is configured, the client must provide an access token
instead of an identity token for authorization purposes.
- `"authorizerId"`: Specifies the identifier of an Authorizer to use on this Method, if the
type is CUSTOM or COGNITO_USER_POOLS. The authorizer identifier is generated by API Gateway
when you created the authorizer.
- `"operationName"`: A human-friendly operation identifier for the method. For example, you
can assign the operationName of ListPets for the GET /pets method in the PetStore example.
- `"requestModels"`: Specifies the Model resources used for the request's content type.
Request models are represented as a key/value map, with a content type as the key and a
Model name as the value.
- `"requestParameters"`: A key-value map defining required or optional method request
parameters that can be accepted by API Gateway. A key defines a method request parameter
name matching the pattern of method.request.{location}.{name}, where location is
querystring, path, or header and name is a valid and unique parameter name. The value
associated with the key is a Boolean flag indicating whether the parameter is required
(true) or optional (false). The method request parameter names defined here are available
in Integration to be mapped to integration request parameters or body-mapping templates.
- `"requestValidatorId"`: The identifier of a RequestValidator for validating the method
request.
"""
function put_method(
authorizationType,
http_method,
resource_id,
restapi_id;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
Dict{String,Any}("authorizationType" => authorizationType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_method(
authorizationType,
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("authorizationType" => authorizationType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_method_response(http_method, resource_id, restapi_id, status_code)
put_method_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Adds a MethodResponse to an existing Method resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the Method resource.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: The method response's status code.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"responseModels"`: Specifies the Model resources used for the response's content type.
Response models are represented as a key/value map, with a content type as the key and a
Model name as the value.
- `"responseParameters"`: A key-value map specifying required or optional response
parameters that API Gateway can send back to the caller. A key defines a method response
header name and the associated value is a Boolean flag indicating whether the method
response parameter is required or not. The method response header names must match the
pattern of method.response.header.{name}, where name is a valid and unique header name. The
response parameter names defined here are available in the integration response to be
mapped from an integration response header expressed in integration.response.header.{name},
a static value enclosed within a pair of single quotes (e.g., 'application/json'), or a
JSON expression from the back-end response payload in the form of
integration.response.body.{JSON-expression}, where JSON-expression is a valid JSON
expression without the prefix.)
"""
function put_method_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_method_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_rest_api(body, restapi_id)
put_rest_api(body, restapi_id, params::Dict{String,<:Any})
A feature of the API Gateway control service for updating an existing API with an input of
external API definitions. The update can take the form of merging the supplied definition
into the existing API or overwriting the existing API.
# Arguments
- `body`: The PUT request body containing external API definitions. Currently, only OpenAPI
definition JSON/YAML files are supported. The maximum size of the API definition file is
6MB.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"failonwarnings"`: A query parameter to indicate whether to rollback the API update
(true) or not (false) when a warning is encountered. The default value is false.
- `"mode"`: The mode query parameter to specify the update mode. Valid values are \"merge\"
and \"overwrite\". By default, the update mode is \"merge\".
- `"parameters"`: Custom header parameters as part of the request. For example, to exclude
DocumentationParts from an imported API, set ignore=documentation as a parameters value, as
in the AWS CLI command of aws apigateway import-rest-api --parameters ignore=documentation
--body 'file:///path/to/imported-api-body.json'.
"""
function put_rest_api(body, restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PUT",
"/restapis/$(restapi_id)",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_rest_api(
body,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/restapis/$(restapi_id)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds or updates a tag on a given resource.
# Arguments
- `resource_arn`: The ARN of a resource that can be tagged.
- `tags`: The key-value map of strings. The valid character set is [a-zA-Z+-=._:/]. The tag
key can be up to 128 characters and must not start with aws:. The tag value can be up to
256 characters.
"""
function tag_resource(resource_arn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PUT",
"/tags/$(resource_arn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resource_arn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PUT",
"/tags/$(resource_arn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_invoke_authorizer(authorizer_id, restapi_id)
test_invoke_authorizer(authorizer_id, restapi_id, params::Dict{String,<:Any})
Simulate the execution of an Authorizer in your RestApi with headers, parameters, and an
incoming request body.
# Arguments
- `authorizer_id`: Specifies a test invoke authorizer request's Authorizer ID.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalContext"`: A key-value map of additional context variables.
- `"body"`: The simulated request body of an incoming invocation request.
- `"headers"`: A key-value map of headers to simulate an incoming invocation request. This
is where the incoming authorization token, or identity source, should be specified.
- `"multiValueHeaders"`: The headers as a map from string to list of values to simulate an
incoming invocation request. This is where the incoming authorization token, or identity
source, may be specified.
- `"pathWithQueryString"`: The URI path, including query string, of the simulated
invocation request. Use this to specify path parameters and query string parameters.
- `"stageVariables"`: A key-value map of stage variables to simulate an invocation on a
deployed Stage.
"""
function test_invoke_authorizer(
authorizer_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_invoke_authorizer(
authorizer_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_invoke_method(http_method, resource_id, restapi_id)
test_invoke_method(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Simulate the invocation of a Method in your RestApi with headers, parameters, and an
incoming request body.
# Arguments
- `http_method`: Specifies a test invoke method request's HTTP method.
- `resource_id`: Specifies a test invoke method request's resource ID.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"body"`: The simulated request body of an incoming invocation request.
- `"clientCertificateId"`: A ClientCertificate identifier to use in the test invocation.
API Gateway will use the certificate when making the HTTPS request to the defined back-end
endpoint.
- `"headers"`: A key-value map of headers to simulate an incoming invocation request.
- `"multiValueHeaders"`: The headers as a map from string to list of values to simulate an
incoming invocation request.
- `"pathWithQueryString"`: The URI path, including query string, of the simulated
invocation request. Use this to specify path parameters and query string parameters.
- `"stageVariables"`: A key-value map of stage variables to simulate an invocation on a
deployed Stage.
"""
function test_invoke_method(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_invoke_method(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"POST",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag from a given resource.
# Arguments
- `resource_arn`: The ARN of a resource that can be tagged.
- `tag_keys`: The Tag keys to delete.
"""
function untag_resource(
resource_arn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"DELETE",
"/tags/$(resource_arn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resource_arn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"DELETE",
"/tags/$(resource_arn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_account()
update_account(params::Dict{String,<:Any})
Changes information about the current Account resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_account(; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH", "/account"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH", "/account", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_api_key(api__key)
update_api_key(api__key, params::Dict{String,<:Any})
Changes information about an ApiKey resource.
# Arguments
- `api__key`: The identifier of the ApiKey resource to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_api_key(api_Key; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/apikeys/$(api_Key)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_api_key(
api_Key, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/apikeys/$(api_Key)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_authorizer(authorizer_id, restapi_id)
update_authorizer(authorizer_id, restapi_id, params::Dict{String,<:Any})
Updates an existing Authorizer resource.
# Arguments
- `authorizer_id`: The identifier of the Authorizer resource.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_authorizer(
authorizer_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_authorizer(
authorizer_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/authorizers/$(authorizer_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_base_path_mapping(base_path, domain_name)
update_base_path_mapping(base_path, domain_name, params::Dict{String,<:Any})
Changes information about the BasePathMapping resource.
# Arguments
- `base_path`: The base path of the BasePathMapping resource to change. To specify an empty
base path, set this parameter to '(none)'.
- `domain_name`: The domain name of the BasePathMapping resource to change.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_base_path_mapping(
base_path, domain_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_base_path_mapping(
base_path,
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/domainnames/$(domain_name)/basepathmappings/$(base_path)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_client_certificate(clientcertificate_id)
update_client_certificate(clientcertificate_id, params::Dict{String,<:Any})
Changes information about an ClientCertificate resource.
# Arguments
- `clientcertificate_id`: The identifier of the ClientCertificate resource to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_client_certificate(
clientcertificate_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/clientcertificates/$(clientcertificate_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_client_certificate(
clientcertificate_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/clientcertificates/$(clientcertificate_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_deployment(deployment_id, restapi_id)
update_deployment(deployment_id, restapi_id, params::Dict{String,<:Any})
Changes information about a Deployment resource.
# Arguments
- `deployment_id`: The replacement identifier for the Deployment resource to change
information about.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_deployment(
deployment_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/deployments/$(deployment_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_deployment(
deployment_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/deployments/$(deployment_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_documentation_part(part_id, restapi_id)
update_documentation_part(part_id, restapi_id, params::Dict{String,<:Any})
Updates a documentation part.
# Arguments
- `part_id`: The identifier of the to-be-updated documentation part.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_documentation_part(
part_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_documentation_part(
part_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/documentation/parts/$(part_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_documentation_version(doc_version, restapi_id)
update_documentation_version(doc_version, restapi_id, params::Dict{String,<:Any})
Updates a documentation version.
# Arguments
- `doc_version`: The version identifier of the to-be-updated documentation version.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_documentation_version(
doc_version, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_documentation_version(
doc_version,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/documentation/versions/$(doc_version)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_domain_name(domain_name)
update_domain_name(domain_name, params::Dict{String,<:Any})
Changes information about the DomainName resource.
# Arguments
- `domain_name`: The name of the DomainName resource to be changed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_domain_name(domain_name; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/domainnames/$(domain_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_domain_name(
domain_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/domainnames/$(domain_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_gateway_response(response_type, restapi_id)
update_gateway_response(response_type, restapi_id, params::Dict{String,<:Any})
Updates a GatewayResponse of a specified response type on the given RestApi.
# Arguments
- `response_type`: The response type of the associated GatewayResponse.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_gateway_response(
response_type, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_gateway_response(
response_type,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/gatewayresponses/$(response_type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_integration(http_method, resource_id, restapi_id)
update_integration(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Represents an update integration.
# Arguments
- `http_method`: Represents an update integration request's HTTP method.
- `resource_id`: Represents an update integration request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_integration(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_integration(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_integration_response(http_method, resource_id, restapi_id, status_code)
update_integration_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Represents an update integration response.
# Arguments
- `http_method`: Specifies an update integration response request's HTTP method.
- `resource_id`: Specifies an update integration response request's resource identifier.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: Specifies an update integration response request's status code.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_integration_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_integration_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/integration/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_method(http_method, resource_id, restapi_id)
update_method(http_method, resource_id, restapi_id, params::Dict{String,<:Any})
Updates an existing Method resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the Method resource.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_method(
http_method, resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_method(
http_method,
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_method_response(http_method, resource_id, restapi_id, status_code)
update_method_response(http_method, resource_id, restapi_id, status_code, params::Dict{String,<:Any})
Updates an existing MethodResponse resource.
# Arguments
- `http_method`: The HTTP verb of the Method resource.
- `resource_id`: The Resource identifier for the MethodResponse resource.
- `restapi_id`: The string identifier of the associated RestApi.
- `status_code`: The status code for the MethodResponse resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_method_response(
http_method,
resource_id,
restapi_id,
status_code;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_method_response(
http_method,
resource_id,
restapi_id,
status_code,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)/methods/$(http_method)/responses/$(status_code)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_model(model_name, restapi_id)
update_model(model_name, restapi_id, params::Dict{String,<:Any})
Changes information about a model. The maximum size of the model is 400 KB.
# Arguments
- `model_name`: The name of the model to update.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_model(
model_name, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/models/$(model_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_model(
model_name,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/models/$(model_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_request_validator(requestvalidator_id, restapi_id)
update_request_validator(requestvalidator_id, restapi_id, params::Dict{String,<:Any})
Updates a RequestValidator of a given RestApi.
# Arguments
- `requestvalidator_id`: The identifier of RequestValidator to be updated.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_request_validator(
requestvalidator_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_request_validator(
requestvalidator_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/requestvalidators/$(requestvalidator_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_resource(resource_id, restapi_id)
update_resource(resource_id, restapi_id, params::Dict{String,<:Any})
Changes information about a Resource resource.
# Arguments
- `resource_id`: The identifier of the Resource resource.
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_resource(
resource_id, restapi_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_resource(
resource_id,
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/resources/$(resource_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_rest_api(restapi_id)
update_rest_api(restapi_id, params::Dict{String,<:Any})
Changes information about the specified API.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_rest_api(restapi_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_rest_api(
restapi_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stage(restapi_id, stage_name)
update_stage(restapi_id, stage_name, params::Dict{String,<:Any})
Changes information about a Stage resource.
# Arguments
- `restapi_id`: The string identifier of the associated RestApi.
- `stage_name`: The name of the Stage resource to change information about.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_stage(
restapi_id, stage_name; aws_config::AbstractAWSConfig=global_aws_config()
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/stages/$(stage_name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stage(
restapi_id,
stage_name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/restapis/$(restapi_id)/stages/$(stage_name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_usage(key_id, usageplan_id)
update_usage(key_id, usageplan_id, params::Dict{String,<:Any})
Grants a temporary extension to the remaining quota of a usage plan associated with a
specified API key.
# Arguments
- `key_id`: The identifier of the API key associated with the usage plan in which a
temporary extension is granted to the remaining quota.
- `usageplan_id`: The Id of the usage plan associated with the usage data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_usage(keyId, usageplanId; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/usageplans/$(usageplanId)/keys/$(keyId)/usage";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_usage(
keyId,
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/usageplans/$(usageplanId)/keys/$(keyId)/usage",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_usage_plan(usageplan_id)
update_usage_plan(usageplan_id, params::Dict{String,<:Any})
Updates a usage plan of a given plan Id.
# Arguments
- `usageplan_id`: The Id of the to-be-updated usage plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_usage_plan(usageplanId; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/usageplans/$(usageplanId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_usage_plan(
usageplanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/usageplans/$(usageplanId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_vpc_link(vpclink_id)
update_vpc_link(vpclink_id, params::Dict{String,<:Any})
Updates an existing VpcLink of a specified identifier.
# Arguments
- `vpclink_id`: The identifier of the VpcLink. It is used in an Integration to reference
this VpcLink.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"patchOperations"`: For more information about supported patch operations, see Patch
Operations.
"""
function update_vpc_link(vpclink_id; aws_config::AbstractAWSConfig=global_aws_config())
return api_gateway(
"PATCH",
"/vpclinks/$(vpclink_id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_vpc_link(
vpclink_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return api_gateway(
"PATCH",
"/vpclinks/$(vpclink_id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 2797 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: apigatewaymanagementapi
using AWS.Compat
using AWS.UUIDs
"""
delete_connection(connection_id)
delete_connection(connection_id, params::Dict{String,<:Any})
Delete the connection with the provided id.
# Arguments
- `connection_id`:
"""
function delete_connection(connectionId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewaymanagementapi(
"DELETE",
"/@connections/$(connectionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_connection(
connectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewaymanagementapi(
"DELETE",
"/@connections/$(connectionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_connection(connection_id)
get_connection(connection_id, params::Dict{String,<:Any})
Get information about the connection with the provided id.
# Arguments
- `connection_id`:
"""
function get_connection(connectionId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewaymanagementapi(
"GET",
"/@connections/$(connectionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_connection(
connectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewaymanagementapi(
"GET",
"/@connections/$(connectionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
post_to_connection(data, connection_id)
post_to_connection(data, connection_id, params::Dict{String,<:Any})
Sends the provided data to the specified connection.
# Arguments
- `data`: The data to be sent to the client specified by its connection id.
- `connection_id`: The identifier of the connection that a specific client is using.
"""
function post_to_connection(
Data, connectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewaymanagementapi(
"POST",
"/@connections/$(connectionId)",
Dict{String,Any}("Data" => Data);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function post_to_connection(
Data,
connectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewaymanagementapi(
"POST",
"/@connections/$(connectionId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Data" => Data), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 109425 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: apigatewayv2
using AWS.Compat
using AWS.UUIDs
"""
create_api(name, protocol_type)
create_api(name, protocol_type, params::Dict{String,<:Any})
Creates an Api resource.
# Arguments
- `name`: The name of the API.
- `protocol_type`: The API protocol.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeySelectionExpression"`: An API key selection expression. Supported only for
WebSocket APIs. See API Key Selection Expressions.
- `"corsConfiguration"`: A CORS configuration. Supported only for HTTP APIs. See
Configuring CORS for more information.
- `"credentialsArn"`: This property is part of quick create. It specifies the credentials
required for the integration, if any. For a Lambda integration, three options are
available. To specify an IAM Role for API Gateway to assume, use the role's Amazon Resource
Name (ARN). To require that the caller's identity be passed through from the request,
specify arn:aws:iam::*:user/*. To use resource-based permissions on supported AWS services,
specify null. Currently, this property is not used for HTTP integrations. Supported only
for HTTP APIs.
- `"description"`: The description of the API.
- `"disableExecuteApiEndpoint"`: Specifies whether clients can invoke your API by using the
default execute-api endpoint. By default, clients can invoke your API with the default
https://{api_id}.execute-api.{region}.amazonaws.com endpoint. To require that clients use a
custom domain name to invoke your API, disable the default endpoint.
- `"disableSchemaValidation"`: Avoid validating models when creating a deployment.
Supported only for WebSocket APIs.
- `"routeKey"`: This property is part of quick create. If you don't specify a routeKey, a
default route of default is created. The default route acts as a catch-all for any request
made to your API, for a particular stage. The default route key can't be modified. You can
add routes after creating the API, and you can update the route keys of additional routes.
Supported only for HTTP APIs.
- `"routeSelectionExpression"`: The route selection expression for the API. For HTTP APIs,
the routeSelectionExpression must be {request.method} {request.path}. If not provided, this
will be the default for HTTP APIs. This property is required for WebSocket APIs.
- `"tags"`: The collection of tags. Each tag element is associated with a given resource.
- `"target"`: This property is part of quick create. Quick create produces an API with an
integration, a default catch-all route, and a default stage which is configured to
automatically deploy changes. For HTTP integrations, specify a fully qualified URL. For
Lambda integrations, specify a function ARN. The type of the integration will be HTTP_PROXY
or AWS_PROXY, respectively. Supported only for HTTP APIs.
- `"version"`: A version identifier for the API.
"""
function create_api(name, protocolType; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/apis",
Dict{String,Any}("name" => name, "protocolType" => protocolType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_api(
name,
protocolType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("name" => name, "protocolType" => protocolType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_api_mapping(api_id, domain_name, stage)
create_api_mapping(api_id, domain_name, stage, params::Dict{String,<:Any})
Creates an API mapping.
# Arguments
- `api_id`: The API identifier.
- `domain_name`: The domain name.
- `stage`: The API stage.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiMappingKey"`: The API mapping key.
"""
function create_api_mapping(
apiId, domainName, stage; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"POST",
"/v2/domainnames/$(domainName)/apimappings",
Dict{String,Any}("apiId" => apiId, "stage" => stage);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_api_mapping(
apiId,
domainName,
stage,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/domainnames/$(domainName)/apimappings",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("apiId" => apiId, "stage" => stage), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_authorizer(api_id, authorizer_type, identity_source, name)
create_authorizer(api_id, authorizer_type, identity_source, name, params::Dict{String,<:Any})
Creates an Authorizer for an API.
# Arguments
- `api_id`: The API identifier.
- `authorizer_type`: The authorizer type. Specify REQUEST for a Lambda function using
incoming request parameters. Specify JWT to use JSON Web Tokens (supported only for HTTP
APIs).
- `identity_source`: The identity source for which authorization is requested. For a
REQUEST authorizer, this is optional. The value is a set of one or more mapping expressions
of the specified request parameters. The identity source can be headers, query string
parameters, stage variables, and context parameters. For example, if an Auth header and a
Name query string parameter are defined as identity sources, this value is
route.request.header.Auth, route.request.querystring.Name for WebSocket APIs. For HTTP
APIs, use selection expressions prefixed with , for example, request.header.Auth,
request.querystring.Name. These parameters are used to perform runtime validation for
Lambda-based authorizers by verifying all of the identity-related request parameters are
present in the request, not null, and non-empty. Only when this is true does the authorizer
invoke the authorizer Lambda function. Otherwise, it returns a 401 Unauthorized response
without calling the Lambda function. For HTTP APIs, identity sources are also used as the
cache key when caching is enabled. To learn more, see Working with AWS Lambda authorizers
for HTTP APIs. For JWT, a single entry that specifies where to extract the JSON Web Token
(JWT) from inbound requests. Currently only header-based and query parameter-based
selections are supported, for example request.header.Authorization.
- `name`: The name of the authorizer.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorizerCredentialsArn"`: Specifies the required credentials as an IAM role for API
Gateway to invoke the authorizer. To specify an IAM role for API Gateway to assume, use the
role's Amazon Resource Name (ARN). To use resource-based permissions on the Lambda
function, don't specify this parameter. Supported only for REQUEST authorizers.
- `"authorizerPayloadFormatVersion"`: Specifies the format of the payload sent to an HTTP
API Lambda authorizer. Required for HTTP API Lambda authorizers. Supported values are 1.0
and 2.0. To learn more, see Working with AWS Lambda authorizers for HTTP APIs.
- `"authorizerResultTtlInSeconds"`: The time to live (TTL) for cached authorizer results,
in seconds. If it equals 0, authorization caching is disabled. If it is greater than 0, API
Gateway caches authorizer responses. The maximum value is 3600, or 1 hour. Supported only
for HTTP API Lambda authorizers.
- `"authorizerUri"`: The authorizer's Uniform Resource Identifier (URI). For REQUEST
authorizers, this must be a well-formed Lambda function URI, for example,
arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:{acco
unt_id}:function:{lambda_function_name}/invocations. In general, the URI has this form:
arn:aws:apigateway:{region}:lambda:path/{service_api}
, where {region} is
the same as the region hosting the Lambda function, path indicates that the remaining
substring in the URI should be treated as the path to the resource, including the initial
/. For Lambda functions, this is usually of the form
/2015-03-31/functions/[FunctionARN]/invocations. Supported only for REQUEST authorizers.
- `"enableSimpleResponses"`: Specifies whether a Lambda authorizer returns a response in a
simple format. By default, a Lambda authorizer must return an IAM policy. If enabled, the
Lambda authorizer can return a boolean value instead of an IAM policy. Supported only for
HTTP APIs. To learn more, see Working with AWS Lambda authorizers for HTTP APIs
- `"identityValidationExpression"`: This parameter is not used.
- `"jwtConfiguration"`: Represents the configuration of a JWT authorizer. Required for the
JWT authorizer type. Supported only for HTTP APIs.
"""
function create_authorizer(
apiId,
authorizerType,
identitySource,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/authorizers",
Dict{String,Any}(
"authorizerType" => authorizerType,
"identitySource" => identitySource,
"name" => name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_authorizer(
apiId,
authorizerType,
identitySource,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/authorizers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"authorizerType" => authorizerType,
"identitySource" => identitySource,
"name" => name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment(api_id)
create_deployment(api_id, params::Dict{String,<:Any})
Creates a Deployment for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description for the deployment resource.
- `"stageName"`: The name of the Stage resource for the Deployment resource to create.
"""
function create_deployment(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain_name(domain_name)
create_domain_name(domain_name, params::Dict{String,<:Any})
Creates a domain name.
# Arguments
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainNameConfigurations"`: The domain name configurations.
- `"mutualTlsAuthentication"`: The mutual TLS authentication configuration for a custom
domain name.
- `"tags"`: The collection of tags associated with a domain name.
"""
function create_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/domainnames",
Dict{String,Any}("domainName" => domainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/domainnames",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("domainName" => domainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_integration(api_id, integration_type)
create_integration(api_id, integration_type, params::Dict{String,<:Any})
Creates an Integration.
# Arguments
- `api_id`: The API identifier.
- `integration_type`: The integration type of an integration. One of the following: AWS:
for integrating the route or method request with an AWS service action, including the
Lambda function-invoking action. With the Lambda function-invoking action, this is referred
to as the Lambda custom integration. With any other AWS service action, this is known as
AWS integration. Supported only for WebSocket APIs. AWS_PROXY: for integrating the route or
method request with a Lambda function or other AWS service action. This integration is also
referred to as a Lambda proxy integration. HTTP: for integrating the route or method
request with an HTTP endpoint. This integration is also referred to as the HTTP custom
integration. Supported only for WebSocket APIs. HTTP_PROXY: for integrating the route or
method request with an HTTP endpoint, with the client request passed through as-is. This is
also referred to as HTTP proxy integration. For HTTP API private integrations, use an
HTTP_PROXY integration. MOCK: for integrating the route or method request with API Gateway
as a \"loopback\" endpoint without invoking any backend. Supported only for WebSocket APIs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"connectionId"`: The ID of the VPC link for a private integration. Supported only for
HTTP APIs.
- `"connectionType"`: The type of the network connection to the integration endpoint.
Specify INTERNET for connections through the public routable internet or VPC_LINK for
private connections between API Gateway and resources in a VPC. The default value is
INTERNET.
- `"contentHandlingStrategy"`: Supported only for WebSocket APIs. Specifies how to handle
response payload content type conversions. Supported values are CONVERT_TO_BINARY and
CONVERT_TO_TEXT, with the following behaviors: CONVERT_TO_BINARY: Converts a response
payload from a Base64-encoded string to the corresponding binary blob. CONVERT_TO_TEXT:
Converts a response payload from a binary blob to a Base64-encoded string. If this property
is not defined, the response payload will be passed through from the integration response
to the route response or method response without modification.
- `"credentialsArn"`: Specifies the credentials required for the integration, if any. For
AWS integrations, three options are available. To specify an IAM Role for API Gateway to
assume, use the role's Amazon Resource Name (ARN). To require that the caller's identity be
passed through from the request, specify the string arn:aws:iam::*:user/*. To use
resource-based permissions on supported AWS services, specify null.
- `"description"`: The description of the integration.
- `"integrationMethod"`: Specifies the integration's HTTP method type.
- `"integrationSubtype"`: Supported only for HTTP API AWS_PROXY integrations. Specifies the
AWS service action to invoke. To learn more, see Integration subtype reference.
- `"integrationUri"`: For a Lambda integration, specify the URI of a Lambda function. For
an HTTP integration, specify a fully-qualified URL. For an HTTP API private integration,
specify the ARN of an Application Load Balancer listener, Network Load Balancer listener,
or AWS Cloud Map service. If you specify the ARN of an AWS Cloud Map service, API Gateway
uses DiscoverInstances to identify resources. You can use query parameters to target
specific resources. To learn more, see DiscoverInstances. For private integrations, all
resources must be owned by the same AWS account.
- `"passthroughBehavior"`: Specifies the pass-through behavior for incoming requests based
on the Content-Type header in the request, and the available mapping templates specified as
the requestTemplates property on the Integration resource. There are three valid values:
WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and NEVER. Supported only for WebSocket APIs.
WHEN_NO_MATCH passes the request body for unmapped content types through to the integration
backend without transformation. NEVER rejects unmapped content types with an HTTP 415
Unsupported Media Type response. WHEN_NO_TEMPLATES allows pass-through when the integration
has no content types mapped to templates. However, if there is at least one content type
defined, unmapped content types will be rejected with the same HTTP 415 Unsupported Media
Type response.
- `"payloadFormatVersion"`: Specifies the format of the payload sent to an integration.
Required for HTTP APIs.
- `"requestParameters"`: For WebSocket APIs, a key-value map specifying request parameters
that are passed from the method request to the backend. The key is an integration request
parameter name and the associated value is a method request parameter value or static value
that must be enclosed within single quotes and pre-encoded as required by the backend. The
method request parameter value must match the pattern of method.request.{location}.{name}
, where
{location}
is querystring, path, or
header; and
{name}
must be a valid and unique method
request parameter name. For HTTP API integrations with a specified integrationSubtype,
request parameters are a key-value map specifying parameters that are passed to AWS_PROXY
integrations. You can provide static values, or map request data, stage variables, or
context variables that are evaluated at runtime. To learn more, see Working with AWS
service integrations for HTTP APIs. For HTTP API integrations without a specified
integrationSubtype request parameters are a key-value map specifying how to transform HTTP
requests before sending them to the backend. The key should follow the pattern
<action>:<header|querystring|path>.<location> where action can be append,
overwrite or remove. For values, you can provide static values, or map request data, stage
variables, or context variables that are evaluated at runtime. To learn more, see
Transforming API requests and responses.
- `"requestTemplates"`: Represents a map of Velocity templates that are applied on the
request payload based on the value of the Content-Type header sent by the client. The
content type value is the key in this map, and the template (as a String) is the value.
Supported only for WebSocket APIs.
- `"responseParameters"`: Supported only for HTTP APIs. You use response parameters to
transform the HTTP response from a backend integration before returning the response to
clients. Specify a key-value map from a selection key to response parameters. The selection
key must be a valid HTTP status code within the range of 200-599. Response parameters are a
key-value map. The key must match pattern <action>:<header>.<location> or
overwrite.statuscode. The action can be append, overwrite or remove. The value can be a
static value, or map to response data, stage variables, or context variables that are
evaluated at runtime. To learn more, see Transforming API requests and responses.
- `"templateSelectionExpression"`: The template selection expression for the integration.
- `"timeoutInMillis"`: Custom timeout between 50 and 29,000 milliseconds for WebSocket APIs
and between 50 and 30,000 milliseconds for HTTP APIs. The default timeout is 29 seconds for
WebSocket APIs and 30 seconds for HTTP APIs.
- `"tlsConfig"`: The TLS configuration for a private integration. If you specify a TLS
configuration, private integration traffic uses the HTTPS protocol. Supported only for HTTP
APIs.
"""
function create_integration(
apiId, integrationType; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/integrations",
Dict{String,Any}("integrationType" => integrationType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_integration(
apiId,
integrationType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/integrations",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("integrationType" => integrationType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_integration_response(api_id, integration_id, integration_response_key)
create_integration_response(api_id, integration_id, integration_response_key, params::Dict{String,<:Any})
Creates an IntegrationResponses.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
- `integration_response_key`: The integration response key.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentHandlingStrategy"`: Specifies how to handle response payload content type
conversions. Supported values are CONVERT_TO_BINARY and CONVERT_TO_TEXT, with the following
behaviors: CONVERT_TO_BINARY: Converts a response payload from a Base64-encoded string to
the corresponding binary blob. CONVERT_TO_TEXT: Converts a response payload from a binary
blob to a Base64-encoded string. If this property is not defined, the response payload will
be passed through from the integration response to the route response or method response
without modification.
- `"responseParameters"`: A key-value map specifying response parameters that are passed to
the method response from the backend. The key is a method response header parameter name
and the mapped value is an integration response header value, a static value enclosed
within a pair of single quotes, or a JSON expression from the integration response body.
The mapping key must match the pattern of method.response.header.{name}, where {name} is a
valid and unique header name. The mapped non-static value must match the pattern of
integration.response.header.{name} or integration.response.body.{JSON-expression}, where
{name} is a valid and unique response header name and {JSON-expression} is a valid JSON
expression without the prefix.
- `"responseTemplates"`: The collection of response templates for the integration response
as a string-to-string map of key-value pairs. Response templates are represented as a
key/value map, with a content-type as the key and a template as the value.
- `"templateSelectionExpression"`: The template selection expression for the integration
response. Supported only for WebSocket APIs.
"""
function create_integration_response(
apiId,
integrationId,
integrationResponseKey;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses",
Dict{String,Any}("integrationResponseKey" => integrationResponseKey);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_integration_response(
apiId,
integrationId,
integrationResponseKey,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("integrationResponseKey" => integrationResponseKey),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_model(api_id, name, schema)
create_model(api_id, name, schema, params::Dict{String,<:Any})
Creates a Model for an API.
# Arguments
- `api_id`: The API identifier.
- `name`: The name of the model. Must be alphanumeric.
- `schema`: The schema for the model. For application/json models, this should be JSON
schema draft 4 model.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentType"`: The content-type for the model, for example, \"application/json\".
- `"description"`: The description of the model.
"""
function create_model(
apiId, name, schema; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/models",
Dict{String,Any}("name" => name, "schema" => schema);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_model(
apiId,
name,
schema,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/models",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("name" => name, "schema" => schema), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_route(api_id, route_key)
create_route(api_id, route_key, params::Dict{String,<:Any})
Creates a Route for an API.
# Arguments
- `api_id`: The API identifier.
- `route_key`: The route key for the route.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeyRequired"`: Specifies whether an API key is required for the route. Supported
only for WebSocket APIs.
- `"authorizationScopes"`: The authorization scopes supported by this route.
- `"authorizationType"`: The authorization type for the route. For WebSocket APIs, valid
values are NONE for open access, AWS_IAM for using AWS IAM permissions, and CUSTOM for
using a Lambda authorizer For HTTP APIs, valid values are NONE for open access, JWT for
using JSON Web Tokens, AWS_IAM for using AWS IAM permissions, and CUSTOM for using a Lambda
authorizer.
- `"authorizerId"`: The identifier of the Authorizer resource to be associated with this
route. The authorizer identifier is generated by API Gateway when you created the
authorizer.
- `"modelSelectionExpression"`: The model selection expression for the route. Supported
only for WebSocket APIs.
- `"operationName"`: The operation name for the route.
- `"requestModels"`: The request models for the route. Supported only for WebSocket APIs.
- `"requestParameters"`: The request parameters for the route. Supported only for WebSocket
APIs.
- `"routeResponseSelectionExpression"`: The route response selection expression for the
route. Supported only for WebSocket APIs.
- `"target"`: The target for the route.
"""
function create_route(apiId, routeKey; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/routes",
Dict{String,Any}("routeKey" => routeKey);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_route(
apiId,
routeKey,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/routes",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("routeKey" => routeKey), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_route_response(api_id, route_id, route_response_key)
create_route_response(api_id, route_id, route_response_key, params::Dict{String,<:Any})
Creates a RouteResponse for a Route.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
- `route_response_key`: The route response key.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"modelSelectionExpression"`: The model selection expression for the route response.
Supported only for WebSocket APIs.
- `"responseModels"`: The response models for the route response.
- `"responseParameters"`: The route response parameters.
"""
function create_route_response(
apiId, routeId, routeResponseKey; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses",
Dict{String,Any}("routeResponseKey" => routeResponseKey);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_route_response(
apiId,
routeId,
routeResponseKey,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("routeResponseKey" => routeResponseKey), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stage(api_id, stage_name)
create_stage(api_id, stage_name, params::Dict{String,<:Any})
Creates a Stage for an API.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The name of the stage.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accessLogSettings"`: Settings for logging access in this stage.
- `"autoDeploy"`: Specifies whether updates to an API automatically trigger a new
deployment. The default value is false.
- `"clientCertificateId"`: The identifier of a client certificate for a Stage. Supported
only for WebSocket APIs.
- `"defaultRouteSettings"`: The default route settings for the stage.
- `"deploymentId"`: The deployment identifier of the API stage.
- `"description"`: The description for the API stage.
- `"routeSettings"`: Route settings for the stage, by routeKey.
- `"stageVariables"`: A map that defines the stage variables for a Stage. Variable names
can have alphanumeric and underscore characters, and the values must match
[A-Za-z0-9-._~:/?#&=,]+.
- `"tags"`: The collection of tags. Each tag element is associated with a given resource.
"""
function create_stage(apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/stages",
Dict{String,Any}("stageName" => stageName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stage(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/apis/$(apiId)/stages",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("stageName" => stageName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_vpc_link(name, subnet_ids)
create_vpc_link(name, subnet_ids, params::Dict{String,<:Any})
Creates a VPC link.
# Arguments
- `name`: The name of the VPC link.
- `subnet_ids`: A list of subnet IDs to include in the VPC link.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"securityGroupIds"`: A list of security group IDs for the VPC link.
- `"tags"`: A list of tags.
"""
function create_vpc_link(name, subnetIds; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/vpclinks",
Dict{String,Any}("name" => name, "subnetIds" => subnetIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_vpc_link(
name,
subnetIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/vpclinks",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("name" => name, "subnetIds" => subnetIds), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_access_log_settings(api_id, stage_name)
delete_access_log_settings(api_id, stage_name, params::Dict{String,<:Any})
Deletes the AccessLogSettings for a Stage. To disable access logging for a Stage, delete
its AccessLogSettings.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The stage name. Stage names can only contain alphanumeric characters,
hyphens, and underscores. Maximum length is 128 characters.
"""
function delete_access_log_settings(
apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/accesslogsettings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_access_log_settings(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/accesslogsettings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api(api_id)
delete_api(api_id, params::Dict{String,<:Any})
Deletes an Api resource.
# Arguments
- `api_id`: The API identifier.
"""
function delete_api(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api_mapping(api_mapping_id, domain_name)
delete_api_mapping(api_mapping_id, domain_name, params::Dict{String,<:Any})
Deletes an API mapping.
# Arguments
- `api_mapping_id`: The API mapping identifier.
- `domain_name`: The domain name.
"""
function delete_api_mapping(
apiMappingId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api_mapping(
apiMappingId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_authorizer(api_id, authorizer_id)
delete_authorizer(api_id, authorizer_id, params::Dict{String,<:Any})
Deletes an Authorizer.
# Arguments
- `api_id`: The API identifier.
- `authorizer_id`: The authorizer identifier.
"""
function delete_authorizer(
apiId, authorizerId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_authorizer(
apiId,
authorizerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_cors_configuration(api_id)
delete_cors_configuration(api_id, params::Dict{String,<:Any})
Deletes a CORS configuration.
# Arguments
- `api_id`: The API identifier.
"""
function delete_cors_configuration(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/cors";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_cors_configuration(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/cors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_deployment(api_id, deployment_id)
delete_deployment(api_id, deployment_id, params::Dict{String,<:Any})
Deletes a Deployment.
# Arguments
- `api_id`: The API identifier.
- `deployment_id`: The deployment ID.
"""
function delete_deployment(
apiId, deploymentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/deployments/$(deploymentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_deployment(
apiId,
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/deployments/$(deploymentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain_name(domain_name)
delete_domain_name(domain_name, params::Dict{String,<:Any})
Deletes a domain name.
# Arguments
- `domain_name`: The domain name.
"""
function delete_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_integration(api_id, integration_id)
delete_integration(api_id, integration_id, params::Dict{String,<:Any})
Deletes an Integration.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
"""
function delete_integration(
apiId, integrationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/integrations/$(integrationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_integration(
apiId,
integrationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/integrations/$(integrationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_integration_response(api_id, integration_id, integration_response_id)
delete_integration_response(api_id, integration_id, integration_response_id, params::Dict{String,<:Any})
Deletes an IntegrationResponses.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
- `integration_response_id`: The integration response ID.
"""
function delete_integration_response(
apiId,
integrationId,
integrationResponseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_integration_response(
apiId,
integrationId,
integrationResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_model(api_id, model_id)
delete_model(api_id, model_id, params::Dict{String,<:Any})
Deletes a Model.
# Arguments
- `api_id`: The API identifier.
- `model_id`: The model ID.
"""
function delete_model(apiId, modelId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/models/$(modelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_model(
apiId,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/models/$(modelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_route(api_id, route_id)
delete_route(api_id, route_id, params::Dict{String,<:Any})
Deletes a Route.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
"""
function delete_route(apiId, routeId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_route(
apiId,
routeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_route_request_parameter(api_id, request_parameter_key, route_id)
delete_route_request_parameter(api_id, request_parameter_key, route_id, params::Dict{String,<:Any})
Deletes a route request parameter. Supported only for WebSocket APIs.
# Arguments
- `api_id`: The API identifier.
- `request_parameter_key`: The route request parameter key.
- `route_id`: The route ID.
"""
function delete_route_request_parameter(
apiId, requestParameterKey, routeId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)/requestparameters/$(requestParameterKey)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_route_request_parameter(
apiId,
requestParameterKey,
routeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)/requestparameters/$(requestParameterKey)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_route_response(api_id, route_id, route_response_id)
delete_route_response(api_id, route_id, route_response_id, params::Dict{String,<:Any})
Deletes a RouteResponse.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
- `route_response_id`: The route response ID.
"""
function delete_route_response(
apiId, routeId, routeResponseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_route_response(
apiId,
routeId,
routeResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_route_settings(api_id, route_key, stage_name)
delete_route_settings(api_id, route_key, stage_name, params::Dict{String,<:Any})
Deletes the RouteSettings for a stage.
# Arguments
- `api_id`: The API identifier.
- `route_key`: The route key.
- `stage_name`: The stage name. Stage names can only contain alphanumeric characters,
hyphens, and underscores. Maximum length is 128 characters.
"""
function delete_route_settings(
apiId, routeKey, stageName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/routesettings/$(routeKey)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_route_settings(
apiId,
routeKey,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/routesettings/$(routeKey)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stage(api_id, stage_name)
delete_stage(api_id, stage_name, params::Dict{String,<:Any})
Deletes a Stage.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The stage name. Stage names can only contain alphanumeric characters,
hyphens, and underscores. Maximum length is 128 characters.
"""
function delete_stage(apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stage(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_vpc_link(vpc_link_id)
delete_vpc_link(vpc_link_id, params::Dict{String,<:Any})
Deletes a VPC link.
# Arguments
- `vpc_link_id`: The ID of the VPC link.
"""
function delete_vpc_link(vpcLinkId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"DELETE",
"/v2/vpclinks/$(vpcLinkId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_vpc_link(
vpcLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/vpclinks/$(vpcLinkId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_api(api_id, output_type, specification)
export_api(api_id, output_type, specification, params::Dict{String,<:Any})
# Arguments
- `api_id`: The API identifier.
- `output_type`: The output type of the exported definition file. Valid values are JSON and
YAML.
- `specification`: The version of the API specification to use. OAS30, for OpenAPI 3.0, is
the only supported value.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"exportVersion"`: The version of the API Gateway export algorithm. API Gateway uses the
latest version by default. Currently, the only supported version is 1.0.
- `"includeExtensions"`: Specifies whether to include API Gateway extensions in the
exported API definition. API Gateway extensions are included by default.
- `"stageName"`: The name of the API stage to export. If you don't specify this property, a
representation of the latest API configuration is exported.
"""
function export_api(
apiId, outputType, specification; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/exports/$(specification)",
Dict{String,Any}("outputType" => outputType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_api(
apiId,
outputType,
specification,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/exports/$(specification)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("outputType" => outputType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api(api_id)
get_api(api_id, params::Dict{String,<:Any})
Gets an Api resource.
# Arguments
- `api_id`: The API identifier.
"""
function get_api(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET", "/v2/apis/$(apiId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_api(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api_mapping(api_mapping_id, domain_name)
get_api_mapping(api_mapping_id, domain_name, params::Dict{String,<:Any})
Gets an API mapping.
# Arguments
- `api_mapping_id`: The API mapping identifier.
- `domain_name`: The domain name.
"""
function get_api_mapping(
apiMappingId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_api_mapping(
apiMappingId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api_mappings(domain_name)
get_api_mappings(domain_name, params::Dict{String,<:Any})
Gets API mappings.
# Arguments
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_api_mappings(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)/apimappings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_api_mappings(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)/apimappings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_apis()
get_apis(params::Dict{String,<:Any})
Gets a collection of Api resources.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_apis(; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET", "/v2/apis"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_apis(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET", "/v2/apis", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_authorizer(api_id, authorizer_id)
get_authorizer(api_id, authorizer_id, params::Dict{String,<:Any})
Gets an Authorizer.
# Arguments
- `api_id`: The API identifier.
- `authorizer_id`: The authorizer identifier.
"""
function get_authorizer(
apiId, authorizerId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_authorizer(
apiId,
authorizerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_authorizers(api_id)
get_authorizers(api_id, params::Dict{String,<:Any})
Gets the Authorizers for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_authorizers(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/authorizers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_authorizers(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/authorizers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment(api_id, deployment_id)
get_deployment(api_id, deployment_id, params::Dict{String,<:Any})
Gets a Deployment.
# Arguments
- `api_id`: The API identifier.
- `deployment_id`: The deployment ID.
"""
function get_deployment(
apiId, deploymentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/deployments/$(deploymentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment(
apiId,
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/deployments/$(deploymentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployments(api_id)
get_deployments(api_id, params::Dict{String,<:Any})
Gets the Deployments for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_deployments(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployments(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_name(domain_name)
get_domain_name(domain_name, params::Dict{String,<:Any})
Gets a domain name.
# Arguments
- `domain_name`: The domain name.
"""
function get_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_names()
get_domain_names(params::Dict{String,<:Any})
Gets the domain names for an AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_domain_names(; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET", "/v2/domainnames"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_domain_names(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/domainnames",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integration(api_id, integration_id)
get_integration(api_id, integration_id, params::Dict{String,<:Any})
Gets an Integration.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
"""
function get_integration(
apiId, integrationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integration(
apiId,
integrationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integration_response(api_id, integration_id, integration_response_id)
get_integration_response(api_id, integration_id, integration_response_id, params::Dict{String,<:Any})
Gets an IntegrationResponses.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
- `integration_response_id`: The integration response ID.
"""
function get_integration_response(
apiId,
integrationId,
integrationResponseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integration_response(
apiId,
integrationId,
integrationResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integration_responses(api_id, integration_id)
get_integration_responses(api_id, integration_id, params::Dict{String,<:Any})
Gets the IntegrationResponses for an Integration.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_integration_responses(
apiId, integrationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integration_responses(
apiId,
integrationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_integrations(api_id)
get_integrations(api_id, params::Dict{String,<:Any})
Gets the Integrations for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_integrations(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_integrations(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/integrations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model(api_id, model_id)
get_model(api_id, model_id, params::Dict{String,<:Any})
Gets a Model.
# Arguments
- `api_id`: The API identifier.
- `model_id`: The model ID.
"""
function get_model(apiId, modelId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models/$(modelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model(
apiId,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models/$(modelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model_template(api_id, model_id)
get_model_template(api_id, model_id, params::Dict{String,<:Any})
Gets a model template.
# Arguments
- `api_id`: The API identifier.
- `model_id`: The model ID.
"""
function get_model_template(
apiId, modelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models/$(modelId)/template";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model_template(
apiId,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models/$(modelId)/template",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_models(api_id)
get_models(api_id, params::Dict{String,<:Any})
Gets the Models for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_models(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_models(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/models",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_route(api_id, route_id)
get_route(api_id, route_id, params::Dict{String,<:Any})
Gets a Route.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
"""
function get_route(apiId, routeId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_route(
apiId,
routeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_route_response(api_id, route_id, route_response_id)
get_route_response(api_id, route_id, route_response_id, params::Dict{String,<:Any})
Gets a RouteResponse.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
- `route_response_id`: The route response ID.
"""
function get_route_response(
apiId, routeId, routeResponseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_route_response(
apiId,
routeId,
routeResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_route_responses(api_id, route_id)
get_route_responses(api_id, route_id, params::Dict{String,<:Any})
Gets the RouteResponses for a Route.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_route_responses(
apiId, routeId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_route_responses(
apiId,
routeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_routes(api_id)
get_routes(api_id, params::Dict{String,<:Any})
Gets the Routes for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_routes(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_routes(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/routes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_stage(api_id, stage_name)
get_stage(api_id, stage_name, params::Dict{String,<:Any})
Gets a Stage.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The stage name. Stage names can only contain alphanumeric characters,
hyphens, and underscores. Maximum length is 128 characters.
"""
function get_stage(apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/stages/$(stageName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_stage(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/stages/$(stageName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_stages(api_id)
get_stages(api_id, params::Dict{String,<:Any})
Gets the Stages for an API.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_stages(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/stages";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_stages(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/apis/$(apiId)/stages",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_tags(resource-arn)
get_tags(resource-arn, params::Dict{String,<:Any})
Gets a collection of Tag resources.
# Arguments
- `resource-arn`: The resource ARN for the tag.
"""
function get_tags(resource_arn; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/tags/$(resource-arn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_tags(
resource_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/tags/$(resource-arn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_vpc_link(vpc_link_id)
get_vpc_link(vpc_link_id, params::Dict{String,<:Any})
Gets a VPC link.
# Arguments
- `vpc_link_id`: The ID of the VPC link.
"""
function get_vpc_link(vpcLinkId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET",
"/v2/vpclinks/$(vpcLinkId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_vpc_link(
vpcLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"GET",
"/v2/vpclinks/$(vpcLinkId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_vpc_links()
get_vpc_links(params::Dict{String,<:Any})
Gets a collection of VPC links.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of elements to be returned for this resource.
- `"nextToken"`: The next page of elements from this collection. Not valid for the last
element of the collection.
"""
function get_vpc_links(; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"GET", "/v2/vpclinks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_vpc_links(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"GET",
"/v2/vpclinks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_api(body)
import_api(body, params::Dict{String,<:Any})
Imports an API.
# Arguments
- `body`: The OpenAPI definition. Supported only for HTTP APIs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"basepath"`: Specifies how to interpret the base path of the API during import. Valid
values are ignore, prepend, and split. The default value is ignore. To learn more, see Set
the OpenAPI basePath Property. Supported only for HTTP APIs.
- `"failOnWarnings"`: Specifies whether to rollback the API creation when a warning is
encountered. By default, API creation continues if a warning is encountered.
"""
function import_api(body; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PUT",
"/v2/apis",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_api(
body, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PUT",
"/v2/apis",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
reimport_api(api_id, body)
reimport_api(api_id, body, params::Dict{String,<:Any})
Puts an Api resource.
# Arguments
- `api_id`: The API identifier.
- `body`: The OpenAPI definition. Supported only for HTTP APIs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"basepath"`: Specifies how to interpret the base path of the API during import. Valid
values are ignore, prepend, and split. The default value is ignore. To learn more, see Set
the OpenAPI basePath Property. Supported only for HTTP APIs.
- `"failOnWarnings"`: Specifies whether to rollback the API creation when a warning is
encountered. By default, API creation continues if a warning is encountered.
"""
function reimport_api(apiId, body; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PUT",
"/v2/apis/$(apiId)",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function reimport_api(
apiId,
body,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PUT",
"/v2/apis/$(apiId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
reset_authorizers_cache(api_id, stage_name)
reset_authorizers_cache(api_id, stage_name, params::Dict{String,<:Any})
Resets all authorizer cache entries on a stage. Supported only for HTTP APIs.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The stage name. Stage names can contain only alphanumeric characters,
hyphens, and underscores, or be default. Maximum length is 128 characters.
"""
function reset_authorizers_cache(
apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/cache/authorizers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function reset_authorizers_cache(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/apis/$(apiId)/stages/$(stageName)/cache/authorizers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource-arn)
tag_resource(resource-arn, params::Dict{String,<:Any})
Creates a new Tag resource to represent a tag.
# Arguments
- `resource-arn`: The resource ARN for the tag.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: The collection of tags. Each tag element is associated with a given resource.
"""
function tag_resource(resource_arn; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"POST",
"/v2/tags/$(resource-arn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resource_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"POST",
"/v2/tags/$(resource-arn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource-arn, tag_keys)
untag_resource(resource-arn, tag_keys, params::Dict{String,<:Any})
Deletes a Tag.
# Arguments
- `resource-arn`: The resource ARN for the tag.
- `tag_keys`: The Tag keys to delete
"""
function untag_resource(
resource_arn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"DELETE",
"/v2/tags/$(resource-arn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resource_arn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"DELETE",
"/v2/tags/$(resource-arn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_api(api_id)
update_api(api_id, params::Dict{String,<:Any})
Updates an Api resource.
# Arguments
- `api_id`: The API identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeySelectionExpression"`: An API key selection expression. Supported only for
WebSocket APIs. See API Key Selection Expressions.
- `"corsConfiguration"`: A CORS configuration. Supported only for HTTP APIs.
- `"credentialsArn"`: This property is part of quick create. It specifies the credentials
required for the integration, if any. For a Lambda integration, three options are
available. To specify an IAM Role for API Gateway to assume, use the role's Amazon Resource
Name (ARN). To require that the caller's identity be passed through from the request,
specify arn:aws:iam::*:user/*. To use resource-based permissions on supported AWS services,
don't specify this parameter. Currently, this property is not used for HTTP integrations.
If provided, this value replaces the credentials associated with the quick create
integration. Supported only for HTTP APIs.
- `"description"`: The description of the API.
- `"disableExecuteApiEndpoint"`: Specifies whether clients can invoke your API by using the
default execute-api endpoint. By default, clients can invoke your API with the default
https://{api_id}.execute-api.{region}.amazonaws.com endpoint. To require that clients use a
custom domain name to invoke your API, disable the default endpoint.
- `"disableSchemaValidation"`: Avoid validating models when creating a deployment.
Supported only for WebSocket APIs.
- `"name"`: The name of the API.
- `"routeKey"`: This property is part of quick create. If not specified, the route created
using quick create is kept. Otherwise, this value replaces the route key of the quick
create route. Additional routes may still be added after the API is updated. Supported only
for HTTP APIs.
- `"routeSelectionExpression"`: The route selection expression for the API. For HTTP APIs,
the routeSelectionExpression must be {request.method} {request.path}. If not provided, this
will be the default for HTTP APIs. This property is required for WebSocket APIs.
- `"target"`: This property is part of quick create. For HTTP integrations, specify a fully
qualified URL. For Lambda integrations, specify a function ARN. The type of the integration
will be HTTP_PROXY or AWS_PROXY, respectively. The value provided updates the integration
URI and integration type. You can update a quick-created target, but you can't remove it
from an API. Supported only for HTTP APIs.
- `"version"`: A version identifier for the API.
"""
function update_api(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH", "/v2/apis/$(apiId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_api(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_api_mapping(api_id, api_mapping_id, domain_name)
update_api_mapping(api_id, api_mapping_id, domain_name, params::Dict{String,<:Any})
The API mapping.
# Arguments
- `api_id`: The API identifier.
- `api_mapping_id`: The API mapping identifier.
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiMappingKey"`: The API mapping key.
- `"stage"`: The API stage.
"""
function update_api_mapping(
apiId, apiMappingId, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)",
Dict{String,Any}("apiId" => apiId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_api_mapping(
apiId,
apiMappingId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/domainnames/$(domainName)/apimappings/$(apiMappingId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("apiId" => apiId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_authorizer(api_id, authorizer_id)
update_authorizer(api_id, authorizer_id, params::Dict{String,<:Any})
Updates an Authorizer.
# Arguments
- `api_id`: The API identifier.
- `authorizer_id`: The authorizer identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorizerCredentialsArn"`: Specifies the required credentials as an IAM role for API
Gateway to invoke the authorizer. To specify an IAM role for API Gateway to assume, use the
role's Amazon Resource Name (ARN). To use resource-based permissions on the Lambda
function, don't specify this parameter.
- `"authorizerPayloadFormatVersion"`: Specifies the format of the payload sent to an HTTP
API Lambda authorizer. Required for HTTP API Lambda authorizers. Supported values are 1.0
and 2.0. To learn more, see Working with AWS Lambda authorizers for HTTP APIs.
- `"authorizerResultTtlInSeconds"`: The time to live (TTL) for cached authorizer results,
in seconds. If it equals 0, authorization caching is disabled. If it is greater than 0, API
Gateway caches authorizer responses. The maximum value is 3600, or 1 hour. Supported only
for HTTP API Lambda authorizers.
- `"authorizerType"`: The authorizer type. Specify REQUEST for a Lambda function using
incoming request parameters. Specify JWT to use JSON Web Tokens (supported only for HTTP
APIs).
- `"authorizerUri"`: The authorizer's Uniform Resource Identifier (URI). For REQUEST
authorizers, this must be a well-formed Lambda function URI, for example,
arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:{acco
unt_id}:function:{lambda_function_name}/invocations. In general, the URI has this form:
arn:aws:apigateway:{region}:lambda:path/{service_api}
, where {region} is
the same as the region hosting the Lambda function, path indicates that the remaining
substring in the URI should be treated as the path to the resource, including the initial
/. For Lambda functions, this is usually of the form
/2015-03-31/functions/[FunctionARN]/invocations. Supported only for REQUEST authorizers.
- `"enableSimpleResponses"`: Specifies whether a Lambda authorizer returns a response in a
simple format. By default, a Lambda authorizer must return an IAM policy. If enabled, the
Lambda authorizer can return a boolean value instead of an IAM policy. Supported only for
HTTP APIs. To learn more, see Working with AWS Lambda authorizers for HTTP APIs
- `"identitySource"`: The identity source for which authorization is requested. For a
REQUEST authorizer, this is optional. The value is a set of one or more mapping expressions
of the specified request parameters. The identity source can be headers, query string
parameters, stage variables, and context parameters. For example, if an Auth header and a
Name query string parameter are defined as identity sources, this value is
route.request.header.Auth, route.request.querystring.Name for WebSocket APIs. For HTTP
APIs, use selection expressions prefixed with , for example, request.header.Auth,
request.querystring.Name. These parameters are used to perform runtime validation for
Lambda-based authorizers by verifying all of the identity-related request parameters are
present in the request, not null, and non-empty. Only when this is true does the authorizer
invoke the authorizer Lambda function. Otherwise, it returns a 401 Unauthorized response
without calling the Lambda function. For HTTP APIs, identity sources are also used as the
cache key when caching is enabled. To learn more, see Working with AWS Lambda authorizers
for HTTP APIs. For JWT, a single entry that specifies where to extract the JSON Web Token
(JWT) from inbound requests. Currently only header-based and query parameter-based
selections are supported, for example request.header.Authorization.
- `"identityValidationExpression"`: This parameter is not used.
- `"jwtConfiguration"`: Represents the configuration of a JWT authorizer. Required for the
JWT authorizer type. Supported only for HTTP APIs.
- `"name"`: The name of the authorizer.
"""
function update_authorizer(
apiId, authorizerId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_authorizer(
apiId,
authorizerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/authorizers/$(authorizerId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_deployment(api_id, deployment_id)
update_deployment(api_id, deployment_id, params::Dict{String,<:Any})
Updates a Deployment.
# Arguments
- `api_id`: The API identifier.
- `deployment_id`: The deployment ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description for the deployment resource.
"""
function update_deployment(
apiId, deploymentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/deployments/$(deploymentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_deployment(
apiId,
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/deployments/$(deploymentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_domain_name(domain_name)
update_domain_name(domain_name, params::Dict{String,<:Any})
Updates a domain name.
# Arguments
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainNameConfigurations"`: The domain name configurations.
- `"mutualTlsAuthentication"`: The mutual TLS authentication configuration for a custom
domain name.
"""
function update_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH",
"/v2/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_integration(api_id, integration_id)
update_integration(api_id, integration_id, params::Dict{String,<:Any})
Updates an Integration.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"connectionId"`: The ID of the VPC link for a private integration. Supported only for
HTTP APIs.
- `"connectionType"`: The type of the network connection to the integration endpoint.
Specify INTERNET for connections through the public routable internet or VPC_LINK for
private connections between API Gateway and resources in a VPC. The default value is
INTERNET.
- `"contentHandlingStrategy"`: Supported only for WebSocket APIs. Specifies how to handle
response payload content type conversions. Supported values are CONVERT_TO_BINARY and
CONVERT_TO_TEXT, with the following behaviors: CONVERT_TO_BINARY: Converts a response
payload from a Base64-encoded string to the corresponding binary blob. CONVERT_TO_TEXT:
Converts a response payload from a binary blob to a Base64-encoded string. If this property
is not defined, the response payload will be passed through from the integration response
to the route response or method response without modification.
- `"credentialsArn"`: Specifies the credentials required for the integration, if any. For
AWS integrations, three options are available. To specify an IAM Role for API Gateway to
assume, use the role's Amazon Resource Name (ARN). To require that the caller's identity be
passed through from the request, specify the string arn:aws:iam::*:user/*. To use
resource-based permissions on supported AWS services, specify null.
- `"description"`: The description of the integration
- `"integrationMethod"`: Specifies the integration's HTTP method type.
- `"integrationSubtype"`: Supported only for HTTP API AWS_PROXY integrations. Specifies the
AWS service action to invoke. To learn more, see Integration subtype reference.
- `"integrationType"`: The integration type of an integration. One of the following: AWS:
for integrating the route or method request with an AWS service action, including the
Lambda function-invoking action. With the Lambda function-invoking action, this is referred
to as the Lambda custom integration. With any other AWS service action, this is known as
AWS integration. Supported only for WebSocket APIs. AWS_PROXY: for integrating the route or
method request with a Lambda function or other AWS service action. This integration is also
referred to as a Lambda proxy integration. HTTP: for integrating the route or method
request with an HTTP endpoint. This integration is also referred to as the HTTP custom
integration. Supported only for WebSocket APIs. HTTP_PROXY: for integrating the route or
method request with an HTTP endpoint, with the client request passed through as-is. This is
also referred to as HTTP proxy integration. For HTTP API private integrations, use an
HTTP_PROXY integration. MOCK: for integrating the route or method request with API Gateway
as a \"loopback\" endpoint without invoking any backend. Supported only for WebSocket APIs.
- `"integrationUri"`: For a Lambda integration, specify the URI of a Lambda function. For
an HTTP integration, specify a fully-qualified URL. For an HTTP API private integration,
specify the ARN of an Application Load Balancer listener, Network Load Balancer listener,
or AWS Cloud Map service. If you specify the ARN of an AWS Cloud Map service, API Gateway
uses DiscoverInstances to identify resources. You can use query parameters to target
specific resources. To learn more, see DiscoverInstances. For private integrations, all
resources must be owned by the same AWS account.
- `"passthroughBehavior"`: Specifies the pass-through behavior for incoming requests based
on the Content-Type header in the request, and the available mapping templates specified as
the requestTemplates property on the Integration resource. There are three valid values:
WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and NEVER. Supported only for WebSocket APIs.
WHEN_NO_MATCH passes the request body for unmapped content types through to the integration
backend without transformation. NEVER rejects unmapped content types with an HTTP 415
Unsupported Media Type response. WHEN_NO_TEMPLATES allows pass-through when the integration
has no content types mapped to templates. However, if there is at least one content type
defined, unmapped content types will be rejected with the same HTTP 415 Unsupported Media
Type response.
- `"payloadFormatVersion"`: Specifies the format of the payload sent to an integration.
Required for HTTP APIs.
- `"requestParameters"`: For WebSocket APIs, a key-value map specifying request parameters
that are passed from the method request to the backend. The key is an integration request
parameter name and the associated value is a method request parameter value or static value
that must be enclosed within single quotes and pre-encoded as required by the backend. The
method request parameter value must match the pattern of method.request.{location}.{name}
, where
{location}
is querystring, path, or header; and
{name}
must be a valid and unique method request parameter name. For
HTTP API integrations with a specified integrationSubtype, request parameters are a
key-value map specifying parameters that are passed to AWS_PROXY integrations. You can
provide static values, or map request data, stage variables, or context variables that are
evaluated at runtime. To learn more, see Working with AWS service integrations for HTTP
APIs. For HTTP API integrations, without a specified integrationSubtype request parameters
are a key-value map specifying how to transform HTTP requests before sending them to the
backend. The key should follow the pattern
<action>:<header|querystring|path>.<location> where action can be append,
overwrite or remove. For values, you can provide static values, or map request data, stage
variables, or context variables that are evaluated at runtime. To learn more, see
Transforming API requests and responses.
- `"requestTemplates"`: Represents a map of Velocity templates that are applied on the
request payload based on the value of the Content-Type header sent by the client. The
content type value is the key in this map, and the template (as a String) is the value.
Supported only for WebSocket APIs.
- `"responseParameters"`: Supported only for HTTP APIs. You use response parameters to
transform the HTTP response from a backend integration before returning the response to
clients. Specify a key-value map from a selection key to response parameters. The selection
key must be a valid HTTP status code within the range of 200-599. Response parameters are a
key-value map. The key must match pattern <action>:<header>.<location> or
overwrite.statuscode. The action can be append, overwrite or remove. The value can be a
static value, or map to response data, stage variables, or context variables that are
evaluated at runtime. To learn more, see Transforming API requests and responses.
- `"templateSelectionExpression"`: The template selection expression for the integration.
- `"timeoutInMillis"`: Custom timeout between 50 and 29,000 milliseconds for WebSocket APIs
and between 50 and 30,000 milliseconds for HTTP APIs. The default timeout is 29 seconds for
WebSocket APIs and 30 seconds for HTTP APIs.
- `"tlsConfig"`: The TLS configuration for a private integration. If you specify a TLS
configuration, private integration traffic uses the HTTPS protocol. Supported only for HTTP
APIs.
"""
function update_integration(
apiId, integrationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/integrations/$(integrationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_integration(
apiId,
integrationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/integrations/$(integrationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_integration_response(api_id, integration_id, integration_response_id)
update_integration_response(api_id, integration_id, integration_response_id, params::Dict{String,<:Any})
Updates an IntegrationResponses.
# Arguments
- `api_id`: The API identifier.
- `integration_id`: The integration ID.
- `integration_response_id`: The integration response ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentHandlingStrategy"`: Supported only for WebSocket APIs. Specifies how to handle
response payload content type conversions. Supported values are CONVERT_TO_BINARY and
CONVERT_TO_TEXT, with the following behaviors: CONVERT_TO_BINARY: Converts a response
payload from a Base64-encoded string to the corresponding binary blob. CONVERT_TO_TEXT:
Converts a response payload from a binary blob to a Base64-encoded string. If this property
is not defined, the response payload will be passed through from the integration response
to the route response or method response without modification.
- `"integrationResponseKey"`: The integration response key.
- `"responseParameters"`: A key-value map specifying response parameters that are passed to
the method response from the backend. The key is a method response header parameter name
and the mapped value is an integration response header value, a static value enclosed
within a pair of single quotes, or a JSON expression from the integration response body.
The mapping key must match the pattern of method.response.header.{name}
,
where name is a valid and unique header name. The mapped non-static value must match the
pattern of integration.response.header.{name}
or
integration.response.body.{JSON-expression}
, where
{name}
is a valid and unique response header name and
{JSON-expression}
is a valid JSON expression without the prefix.
- `"responseTemplates"`: The collection of response templates for the integration response
as a string-to-string map of key-value pairs. Response templates are represented as a
key/value map, with a content-type as the key and a template as the value.
- `"templateSelectionExpression"`: The template selection expression for the integration
response. Supported only for WebSocket APIs.
"""
function update_integration_response(
apiId,
integrationId,
integrationResponseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_integration_response(
apiId,
integrationId,
integrationResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/integrations/$(integrationId)/integrationresponses/$(integrationResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_model(api_id, model_id)
update_model(api_id, model_id, params::Dict{String,<:Any})
Updates a Model.
# Arguments
- `api_id`: The API identifier.
- `model_id`: The model ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentType"`: The content-type for the model, for example, \"application/json\".
- `"description"`: The description of the model.
- `"name"`: The name of the model.
- `"schema"`: The schema for the model. For application/json models, this should be JSON
schema draft 4 model.
"""
function update_model(apiId, modelId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/models/$(modelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_model(
apiId,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/models/$(modelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_route(api_id, route_id)
update_route(api_id, route_id, params::Dict{String,<:Any})
Updates a Route.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiKeyRequired"`: Specifies whether an API key is required for the route. Supported
only for WebSocket APIs.
- `"authorizationScopes"`: The authorization scopes supported by this route.
- `"authorizationType"`: The authorization type for the route. For WebSocket APIs, valid
values are NONE for open access, AWS_IAM for using AWS IAM permissions, and CUSTOM for
using a Lambda authorizer For HTTP APIs, valid values are NONE for open access, JWT for
using JSON Web Tokens, AWS_IAM for using AWS IAM permissions, and CUSTOM for using a Lambda
authorizer.
- `"authorizerId"`: The identifier of the Authorizer resource to be associated with this
route. The authorizer identifier is generated by API Gateway when you created the
authorizer.
- `"modelSelectionExpression"`: The model selection expression for the route. Supported
only for WebSocket APIs.
- `"operationName"`: The operation name for the route.
- `"requestModels"`: The request models for the route. Supported only for WebSocket APIs.
- `"requestParameters"`: The request parameters for the route. Supported only for WebSocket
APIs.
- `"routeKey"`: The route key for the route.
- `"routeResponseSelectionExpression"`: The route response selection expression for the
route. Supported only for WebSocket APIs.
- `"target"`: The target for the route.
"""
function update_route(apiId, routeId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/routes/$(routeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_route(
apiId,
routeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/routes/$(routeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_route_response(api_id, route_id, route_response_id)
update_route_response(api_id, route_id, route_response_id, params::Dict{String,<:Any})
Updates a RouteResponse.
# Arguments
- `api_id`: The API identifier.
- `route_id`: The route ID.
- `route_response_id`: The route response ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"modelSelectionExpression"`: The model selection expression for the route response.
Supported only for WebSocket APIs.
- `"responseModels"`: The response models for the route response.
- `"responseParameters"`: The route response parameters.
- `"routeResponseKey"`: The route response key.
"""
function update_route_response(
apiId, routeId, routeResponseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_route_response(
apiId,
routeId,
routeResponseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/routes/$(routeId)/routeresponses/$(routeResponseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stage(api_id, stage_name)
update_stage(api_id, stage_name, params::Dict{String,<:Any})
Updates a Stage.
# Arguments
- `api_id`: The API identifier.
- `stage_name`: The stage name. Stage names can contain only alphanumeric characters,
hyphens, and underscores, or be default. Maximum length is 128 characters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accessLogSettings"`: Settings for logging access in this stage.
- `"autoDeploy"`: Specifies whether updates to an API automatically trigger a new
deployment. The default value is false.
- `"clientCertificateId"`: The identifier of a client certificate for a Stage.
- `"defaultRouteSettings"`: The default route settings for the stage.
- `"deploymentId"`: The deployment identifier for the API stage. Can't be updated if
autoDeploy is enabled.
- `"description"`: The description for the API stage.
- `"routeSettings"`: Route settings for the stage.
- `"stageVariables"`: A map that defines the stage variables for a Stage. Variable names
can have alphanumeric and underscore characters, and the values must match
[A-Za-z0-9-._~:/?#&=,]+.
"""
function update_stage(apiId, stageName; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/stages/$(stageName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stage(
apiId,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/apis/$(apiId)/stages/$(stageName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_vpc_link(vpc_link_id)
update_vpc_link(vpc_link_id, params::Dict{String,<:Any})
Updates a VPC link.
# Arguments
- `vpc_link_id`: The ID of the VPC link.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"name"`: The name of the VPC link.
"""
function update_vpc_link(vpcLinkId; aws_config::AbstractAWSConfig=global_aws_config())
return apigatewayv2(
"PATCH",
"/v2/vpclinks/$(vpcLinkId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_vpc_link(
vpcLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apigatewayv2(
"PATCH",
"/v2/vpclinks/$(vpcLinkId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 73143 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: app_mesh
using AWS.Compat
using AWS.UUIDs
"""
create_gateway_route(gateway_route_name, mesh_name, spec, virtual_gateway_name)
create_gateway_route(gateway_route_name, mesh_name, spec, virtual_gateway_name, params::Dict{String,<:Any})
Creates a gateway route. A gateway route is attached to a virtual gateway and routes
traffic to an existing virtual service. If a route matches a request, it can distribute
traffic to a target virtual service. For more information about gateway routes, see Gateway
routes.
# Arguments
- `gateway_route_name`: The name to use for the gateway route.
- `mesh_name`: The name of the service mesh to create the gateway route in.
- `spec`: The gateway route specification to apply.
- `virtual_gateway_name`: The name of the virtual gateway to associate the gateway route
with. If the virtual gateway is in a shared mesh, then you must be the owner of the virtual
gateway resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the gateway route to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_gateway_route(
gatewayRouteName,
meshName,
spec,
virtualGatewayName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes",
Dict{String,Any}(
"gatewayRouteName" => gatewayRouteName,
"spec" => spec,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_gateway_route(
gatewayRouteName,
meshName,
spec,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"gatewayRouteName" => gatewayRouteName,
"spec" => spec,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_mesh(mesh_name)
create_mesh(mesh_name, params::Dict{String,<:Any})
Creates a service mesh. A service mesh is a logical boundary for network traffic between
services that are represented by resources within the mesh. After you create your service
mesh, you can create virtual services, virtual nodes, virtual routers, and routes to
distribute traffic between the applications in your mesh. For more information about
service meshes, see Service meshes.
# Arguments
- `mesh_name`: The name to use for the service mesh.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"spec"`: The service mesh specification to apply.
- `"tags"`: Optional metadata that you can apply to the service mesh to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_mesh(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"PUT",
"/v20190125/meshes",
Dict{String,Any}("meshName" => meshName, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_mesh(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("meshName" => meshName, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_route(mesh_name, route_name, spec, virtual_router_name)
create_route(mesh_name, route_name, spec, virtual_router_name, params::Dict{String,<:Any})
Creates a route that is associated with a virtual router. You can route several different
protocols and define a retry policy for a route. Traffic can be routed to one or more
virtual nodes. For more information about routes, see Routes.
# Arguments
- `mesh_name`: The name of the service mesh to create the route in.
- `route_name`: The name to use for the route.
- `spec`: The route specification to apply.
- `virtual_router_name`: The name of the virtual router in which to create the route. If
the virtual router is in a shared mesh, then you must be the owner of the virtual router
resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the route to assist with categorization
and organization. Each tag consists of a key and an optional value, both of which you
define. Tag keys can have a maximum character length of 128 characters, and tag values can
have a maximum length of 256 characters.
"""
function create_route(
meshName,
routeName,
spec,
virtualRouterName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes",
Dict{String,Any}(
"routeName" => routeName, "spec" => spec, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_route(
meshName,
routeName,
spec,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"routeName" => routeName,
"spec" => spec,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_virtual_gateway(mesh_name, spec, virtual_gateway_name)
create_virtual_gateway(mesh_name, spec, virtual_gateway_name, params::Dict{String,<:Any})
Creates a virtual gateway. A virtual gateway allows resources outside your mesh to
communicate to resources that are inside your mesh. The virtual gateway represents an Envoy
proxy running in an Amazon ECS task, in a Kubernetes service, or on an Amazon EC2 instance.
Unlike a virtual node, which represents an Envoy running with an application, a virtual
gateway represents Envoy deployed by itself. For more information about virtual gateways,
see Virtual gateways.
# Arguments
- `mesh_name`: The name of the service mesh to create the virtual gateway in.
- `spec`: The virtual gateway specification to apply.
- `virtual_gateway_name`: The name to use for the virtual gateway.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the virtual gateway to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_virtual_gateway(
meshName, spec, virtualGatewayName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateways",
Dict{String,Any}(
"spec" => spec,
"virtualGatewayName" => virtualGatewayName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_virtual_gateway(
meshName,
spec,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateways",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"spec" => spec,
"virtualGatewayName" => virtualGatewayName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_virtual_node(mesh_name, spec, virtual_node_name)
create_virtual_node(mesh_name, spec, virtual_node_name, params::Dict{String,<:Any})
Creates a virtual node within a service mesh. A virtual node acts as a logical pointer to
a particular task group, such as an Amazon ECS service or a Kubernetes deployment. When you
create a virtual node, you can specify the service discovery information for your task
group, and whether the proxy running in a task group will communicate with other proxies
using Transport Layer Security (TLS). You define a listener for any inbound traffic that
your virtual node expects. Any virtual service that your virtual node expects to
communicate to is specified as a backend. The response metadata for your new virtual node
contains the arn that is associated with the virtual node. Set this value to the full ARN;
for example, arn:aws:appmesh:us-west-2:123456789012:myMesh/default/virtualNode/myApp) as
the APPMESH_RESOURCE_ARN environment variable for your task group's Envoy proxy container
in your task definition or pod spec. This is then mapped to the node.id and node.cluster
Envoy parameters. By default, App Mesh uses the name of the resource you specified in
APPMESH_RESOURCE_ARN when Envoy is referring to itself in metrics and traces. You can
override this behavior by setting the APPMESH_RESOURCE_CLUSTER environment variable with
your own name. For more information about virtual nodes, see Virtual nodes. You must be
using 1.15.0 or later of the Envoy image when setting these variables. For more information
aboutApp Mesh Envoy variables, see Envoy image in the App Mesh User Guide.
# Arguments
- `mesh_name`: The name of the service mesh to create the virtual node in.
- `spec`: The virtual node specification to apply.
- `virtual_node_name`: The name to use for the virtual node.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the virtual node to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_virtual_node(
meshName, spec, virtualNodeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualNodes",
Dict{String,Any}(
"spec" => spec,
"virtualNodeName" => virtualNodeName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_virtual_node(
meshName,
spec,
virtualNodeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualNodes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"spec" => spec,
"virtualNodeName" => virtualNodeName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_virtual_router(mesh_name, spec, virtual_router_name)
create_virtual_router(mesh_name, spec, virtual_router_name, params::Dict{String,<:Any})
Creates a virtual router within a service mesh. Specify a listener for any inbound traffic
that your virtual router receives. Create a virtual router for each protocol and port that
you need to route. Virtual routers handle traffic for one or more virtual services within
your mesh. After you create your virtual router, create and associate routes for your
virtual router that direct incoming requests to different virtual nodes. For more
information about virtual routers, see Virtual routers.
# Arguments
- `mesh_name`: The name of the service mesh to create the virtual router in.
- `spec`: The virtual router specification to apply.
- `virtual_router_name`: The name to use for the virtual router.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the virtual router to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_virtual_router(
meshName, spec, virtualRouterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouters",
Dict{String,Any}(
"spec" => spec,
"virtualRouterName" => virtualRouterName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_virtual_router(
meshName,
spec,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouters",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"spec" => spec,
"virtualRouterName" => virtualRouterName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_virtual_service(mesh_name, spec, virtual_service_name)
create_virtual_service(mesh_name, spec, virtual_service_name, params::Dict{String,<:Any})
Creates a virtual service within a service mesh. A virtual service is an abstraction of a
real service that is provided by a virtual node directly or indirectly by means of a
virtual router. Dependent services call your virtual service by its virtualServiceName, and
those requests are routed to the virtual node or virtual router that is specified as the
provider for the virtual service. For more information about virtual services, see Virtual
services.
# Arguments
- `mesh_name`: The name of the service mesh to create the virtual service in.
- `spec`: The virtual service specification to apply.
- `virtual_service_name`: The name to use for the virtual service.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then the account that you specify must share the mesh with your
account before you can create the resource in the service mesh. For more information about
mesh sharing, see Working with shared meshes.
- `"tags"`: Optional metadata that you can apply to the virtual service to assist with
categorization and organization. Each tag consists of a key and an optional value, both of
which you define. Tag keys can have a maximum character length of 128 characters, and tag
values can have a maximum length of 256 characters.
"""
function create_virtual_service(
meshName, spec, virtualServiceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualServices",
Dict{String,Any}(
"spec" => spec,
"virtualServiceName" => virtualServiceName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_virtual_service(
meshName,
spec,
virtualServiceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualServices",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"spec" => spec,
"virtualServiceName" => virtualServiceName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_gateway_route(gateway_route_name, mesh_name, virtual_gateway_name)
delete_gateway_route(gateway_route_name, mesh_name, virtual_gateway_name, params::Dict{String,<:Any})
Deletes an existing gateway route.
# Arguments
- `gateway_route_name`: The name of the gateway route to delete.
- `mesh_name`: The name of the service mesh to delete the gateway route from.
- `virtual_gateway_name`: The name of the virtual gateway to delete the route from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_gateway_route(
gatewayRouteName,
meshName,
virtualGatewayName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_gateway_route(
gatewayRouteName,
meshName,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_mesh(mesh_name)
delete_mesh(mesh_name, params::Dict{String,<:Any})
Deletes an existing service mesh. You must delete all resources (virtual services, routes,
virtual routers, and virtual nodes) in the service mesh before you can delete the mesh
itself.
# Arguments
- `mesh_name`: The name of the service mesh to delete.
"""
function delete_mesh(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_mesh(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_route(mesh_name, route_name, virtual_router_name)
delete_route(mesh_name, route_name, virtual_router_name, params::Dict{String,<:Any})
Deletes an existing route.
# Arguments
- `mesh_name`: The name of the service mesh to delete the route in.
- `route_name`: The name of the route to delete.
- `virtual_router_name`: The name of the virtual router to delete the route in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_route(
meshName,
routeName,
virtualRouterName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_route(
meshName,
routeName,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_virtual_gateway(mesh_name, virtual_gateway_name)
delete_virtual_gateway(mesh_name, virtual_gateway_name, params::Dict{String,<:Any})
Deletes an existing virtual gateway. You cannot delete a virtual gateway if any gateway
routes are associated to it.
# Arguments
- `mesh_name`: The name of the service mesh to delete the virtual gateway from.
- `virtual_gateway_name`: The name of the virtual gateway to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_virtual_gateway(
meshName, virtualGatewayName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_virtual_gateway(
meshName,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_virtual_node(mesh_name, virtual_node_name)
delete_virtual_node(mesh_name, virtual_node_name, params::Dict{String,<:Any})
Deletes an existing virtual node. You must delete any virtual services that list a virtual
node as a service provider before you can delete the virtual node itself.
# Arguments
- `mesh_name`: The name of the service mesh to delete the virtual node in.
- `virtual_node_name`: The name of the virtual node to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_virtual_node(
meshName, virtualNodeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_virtual_node(
meshName,
virtualNodeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_virtual_router(mesh_name, virtual_router_name)
delete_virtual_router(mesh_name, virtual_router_name, params::Dict{String,<:Any})
Deletes an existing virtual router. You must delete any routes associated with the virtual
router before you can delete the router itself.
# Arguments
- `mesh_name`: The name of the service mesh to delete the virtual router in.
- `virtual_router_name`: The name of the virtual router to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_virtual_router(
meshName, virtualRouterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_virtual_router(
meshName,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_virtual_service(mesh_name, virtual_service_name)
delete_virtual_service(mesh_name, virtual_service_name, params::Dict{String,<:Any})
Deletes an existing virtual service.
# Arguments
- `mesh_name`: The name of the service mesh to delete the virtual service in.
- `virtual_service_name`: The name of the virtual service to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function delete_virtual_service(
meshName, virtualServiceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_virtual_service(
meshName,
virtualServiceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"DELETE",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_gateway_route(gateway_route_name, mesh_name, virtual_gateway_name)
describe_gateway_route(gateway_route_name, mesh_name, virtual_gateway_name, params::Dict{String,<:Any})
Describes an existing gateway route.
# Arguments
- `gateway_route_name`: The name of the gateway route to describe.
- `mesh_name`: The name of the service mesh that the gateway route resides in.
- `virtual_gateway_name`: The name of the virtual gateway that the gateway route is
associated with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_gateway_route(
gatewayRouteName,
meshName,
virtualGatewayName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_gateway_route(
gatewayRouteName,
meshName,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_mesh(mesh_name)
describe_mesh(mesh_name, params::Dict{String,<:Any})
Describes an existing service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_mesh(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_mesh(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_route(mesh_name, route_name, virtual_router_name)
describe_route(mesh_name, route_name, virtual_router_name, params::Dict{String,<:Any})
Describes an existing route.
# Arguments
- `mesh_name`: The name of the service mesh that the route resides in.
- `route_name`: The name of the route to describe.
- `virtual_router_name`: The name of the virtual router that the route is associated with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_route(
meshName,
routeName,
virtualRouterName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_route(
meshName,
routeName,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_virtual_gateway(mesh_name, virtual_gateway_name)
describe_virtual_gateway(mesh_name, virtual_gateway_name, params::Dict{String,<:Any})
Describes an existing virtual gateway.
# Arguments
- `mesh_name`: The name of the service mesh that the gateway route resides in.
- `virtual_gateway_name`: The name of the virtual gateway to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_virtual_gateway(
meshName, virtualGatewayName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_virtual_gateway(
meshName,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_virtual_node(mesh_name, virtual_node_name)
describe_virtual_node(mesh_name, virtual_node_name, params::Dict{String,<:Any})
Describes an existing virtual node.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual node resides in.
- `virtual_node_name`: The name of the virtual node to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_virtual_node(
meshName, virtualNodeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_virtual_node(
meshName,
virtualNodeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_virtual_router(mesh_name, virtual_router_name)
describe_virtual_router(mesh_name, virtual_router_name, params::Dict{String,<:Any})
Describes an existing virtual router.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual router resides in.
- `virtual_router_name`: The name of the virtual router to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_virtual_router(
meshName, virtualRouterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_virtual_router(
meshName,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_virtual_service(mesh_name, virtual_service_name)
describe_virtual_service(mesh_name, virtual_service_name, params::Dict{String,<:Any})
Describes an existing virtual service.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual service resides in.
- `virtual_service_name`: The name of the virtual service to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function describe_virtual_service(
meshName, virtualServiceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_virtual_service(
meshName,
virtualServiceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_gateway_routes(mesh_name, virtual_gateway_name)
list_gateway_routes(mesh_name, virtual_gateway_name, params::Dict{String,<:Any})
Returns a list of existing gateway routes that are associated to a virtual gateway.
# Arguments
- `mesh_name`: The name of the service mesh to list gateway routes in.
- `virtual_gateway_name`: The name of the virtual gateway to list gateway routes in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListGatewayRoutes in paginated
output. When you use this parameter, ListGatewayRoutes returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListGatewayRoutes request with the returned
nextToken value. This value can be between 1 and 100. If you don't use this parameter,
ListGatewayRoutes returns up to 100 results and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListGatewayRoutes
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_gateway_routes(
meshName, virtualGatewayName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_gateway_routes(
meshName,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_meshes()
list_meshes(params::Dict{String,<:Any})
Returns a list of existing service meshes.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListMeshes in paginated output. When
you use this parameter, ListMeshes returns only limit results in a single page along with a
nextToken response element. You can see the remaining results of the initial request by
sending another ListMeshes request with the returned nextToken value. This value can be
between 1 and 100. If you don't use this parameter, ListMeshes returns up to 100 results
and a nextToken value if applicable.
- `"nextToken"`: The nextToken value returned from a previous paginated ListMeshes request
where limit was used and the results exceeded the value of that parameter. Pagination
continues from the end of the previous results that returned the nextToken value. This
token should be treated as an opaque identifier that is used only to retrieve the next
items in a list and not for other programmatic purposes.
"""
function list_meshes(; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET", "/v20190125/meshes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_meshes(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_routes(mesh_name, virtual_router_name)
list_routes(mesh_name, virtual_router_name, params::Dict{String,<:Any})
Returns a list of existing routes in a service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to list routes in.
- `virtual_router_name`: The name of the virtual router to list routes in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListRoutes in paginated output. When
you use this parameter, ListRoutes returns only limit results in a single page along with a
nextToken response element. You can see the remaining results of the initial request by
sending another ListRoutes request with the returned nextToken value. This value can be
between 1 and 100. If you don't use this parameter, ListRoutes returns up to 100 results
and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListRoutes request
where limit was used and the results exceeded the value of that parameter. Pagination
continues from the end of the previous results that returned the nextToken value.
"""
function list_routes(
meshName, virtualRouterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_routes(
meshName,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
List the tags for an App Mesh resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) that identifies the resource to list the
tags for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of tag results returned by ListTagsForResource in paginated
output. When this parameter is used, ListTagsForResource returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListTagsForResource request with the returned
nextToken value. This value can be between 1 and 100. If you don't use this parameter,
ListTagsForResource returns up to 100 results and a nextToken value if applicable.
- `"nextToken"`: The nextToken value returned from a previous paginated ListTagsForResource
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"GET",
"/v20190125/tags",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/tags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_virtual_gateways(mesh_name)
list_virtual_gateways(mesh_name, params::Dict{String,<:Any})
Returns a list of existing virtual gateways in a service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to list virtual gateways in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListVirtualGateways in paginated
output. When you use this parameter, ListVirtualGateways returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListVirtualGateways request with the returned
nextToken value. This value can be between 1 and 100. If you don't use this parameter,
ListVirtualGateways returns up to 100 results and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListVirtualGateways
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_virtual_gateways(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateways";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_virtual_gateways(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualGateways",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_virtual_nodes(mesh_name)
list_virtual_nodes(mesh_name, params::Dict{String,<:Any})
Returns a list of existing virtual nodes.
# Arguments
- `mesh_name`: The name of the service mesh to list virtual nodes in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListVirtualNodes in paginated
output. When you use this parameter, ListVirtualNodes returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListVirtualNodes request with the returned nextToken
value. This value can be between 1 and 100. If you don't use this parameter,
ListVirtualNodes returns up to 100 results and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListVirtualNodes
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_virtual_nodes(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualNodes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_virtual_nodes(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualNodes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_virtual_routers(mesh_name)
list_virtual_routers(mesh_name, params::Dict{String,<:Any})
Returns a list of existing virtual routers in a service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to list virtual routers in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListVirtualRouters in paginated
output. When you use this parameter, ListVirtualRouters returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListVirtualRouters request with the returned
nextToken value. This value can be between 1 and 100. If you don't use this parameter,
ListVirtualRouters returns up to 100 results and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListVirtualRouters
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_virtual_routers(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouters";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_virtual_routers(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualRouters",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_virtual_services(mesh_name)
list_virtual_services(mesh_name, params::Dict{String,<:Any})
Returns a list of existing virtual services in a service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to list virtual services in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of results returned by ListVirtualServices in paginated
output. When you use this parameter, ListVirtualServices returns only limit results in a
single page along with a nextToken response element. You can see the remaining results of
the initial request by sending another ListVirtualServices request with the returned
nextToken value. This value can be between 1 and 100. If you don't use this parameter,
ListVirtualServices returns up to 100 results and a nextToken value if applicable.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
- `"nextToken"`: The nextToken value returned from a previous paginated ListVirtualServices
request where limit was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken value.
"""
function list_virtual_services(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualServices";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_virtual_services(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"GET",
"/v20190125/meshes/$(meshName)/virtualServices",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associates the specified tags to a resource with the specified resourceArn. If existing
tags on a resource aren't specified in the request parameters, they aren't changed. When a
resource is deleted, the tags associated with that resource are also deleted.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to add tags to.
- `tags`: The tags to add to the resource. A tag is an array of key-value pairs. Tag keys
can have a maximum character length of 128 characters, and tag values can have a maximum
length of 256 characters.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"PUT",
"/v20190125/tag",
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/tag",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Deletes specified tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to delete tags from.
- `tag_keys`: The keys of the tags to be removed.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/untag",
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/untag",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_gateway_route(gateway_route_name, mesh_name, spec, virtual_gateway_name)
update_gateway_route(gateway_route_name, mesh_name, spec, virtual_gateway_name, params::Dict{String,<:Any})
Updates an existing gateway route that is associated to a specified virtual gateway in a
service mesh.
# Arguments
- `gateway_route_name`: The name of the gateway route to update.
- `mesh_name`: The name of the service mesh that the gateway route resides in.
- `spec`: The new gateway route specification to apply. This overwrites the existing data.
- `virtual_gateway_name`: The name of the virtual gateway that the gateway route is
associated with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_gateway_route(
gatewayRouteName,
meshName,
spec,
virtualGatewayName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_gateway_route(
gatewayRouteName,
meshName,
spec,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateway/$(virtualGatewayName)/gatewayRoutes/$(gatewayRouteName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_mesh(mesh_name)
update_mesh(mesh_name, params::Dict{String,<:Any})
Updates an existing service mesh.
# Arguments
- `mesh_name`: The name of the service mesh to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"spec"`: The service mesh specification to apply.
"""
function update_mesh(meshName; aws_config::AbstractAWSConfig=global_aws_config())
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_mesh(
meshName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_route(mesh_name, route_name, spec, virtual_router_name)
update_route(mesh_name, route_name, spec, virtual_router_name, params::Dict{String,<:Any})
Updates an existing route for a specified service mesh and virtual router.
# Arguments
- `mesh_name`: The name of the service mesh that the route resides in.
- `route_name`: The name of the route to update.
- `spec`: The new route specification to apply. This overwrites the existing data.
- `virtual_router_name`: The name of the virtual router that the route is associated with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_route(
meshName,
routeName,
spec,
virtualRouterName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_route(
meshName,
routeName,
spec,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouter/$(virtualRouterName)/routes/$(routeName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_virtual_gateway(mesh_name, spec, virtual_gateway_name)
update_virtual_gateway(mesh_name, spec, virtual_gateway_name, params::Dict{String,<:Any})
Updates an existing virtual gateway in a specified service mesh.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual gateway resides in.
- `spec`: The new virtual gateway specification to apply. This overwrites the existing data.
- `virtual_gateway_name`: The name of the virtual gateway to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_virtual_gateway(
meshName, spec, virtualGatewayName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_virtual_gateway(
meshName,
spec,
virtualGatewayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualGateways/$(virtualGatewayName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_virtual_node(mesh_name, spec, virtual_node_name)
update_virtual_node(mesh_name, spec, virtual_node_name, params::Dict{String,<:Any})
Updates an existing virtual node in a specified service mesh.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual node resides in.
- `spec`: The new virtual node specification to apply. This overwrites the existing data.
- `virtual_node_name`: The name of the virtual node to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_virtual_node(
meshName, spec, virtualNodeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_virtual_node(
meshName,
spec,
virtualNodeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualNodes/$(virtualNodeName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_virtual_router(mesh_name, spec, virtual_router_name)
update_virtual_router(mesh_name, spec, virtual_router_name, params::Dict{String,<:Any})
Updates an existing virtual router in a specified service mesh.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual router resides in.
- `spec`: The new virtual router specification to apply. This overwrites the existing data.
- `virtual_router_name`: The name of the virtual router to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_virtual_router(
meshName, spec, virtualRouterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_virtual_router(
meshName,
spec,
virtualRouterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualRouters/$(virtualRouterName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_virtual_service(mesh_name, spec, virtual_service_name)
update_virtual_service(mesh_name, spec, virtual_service_name, params::Dict{String,<:Any})
Updates an existing virtual service in a specified service mesh.
# Arguments
- `mesh_name`: The name of the service mesh that the virtual service resides in.
- `spec`: The new virtual service specification to apply. This overwrites the existing data.
- `virtual_service_name`: The name of the virtual service to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
- `"meshOwner"`: The Amazon Web Services IAM account ID of the service mesh owner. If the
account ID is not your own, then it's the ID of the account that shared the mesh with your
account. For more information about mesh sharing, see Working with shared meshes.
"""
function update_virtual_service(
meshName, spec, virtualServiceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)",
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_virtual_service(
meshName,
spec,
virtualServiceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return app_mesh(
"PUT",
"/v20190125/meshes/$(meshName)/virtualServices/$(virtualServiceName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("spec" => spec, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 70650 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appconfig
using AWS.Compat
using AWS.UUIDs
"""
create_application(name)
create_application(name, params::Dict{String,<:Any})
Creates an application. In AppConfig, an application is simply an organizational construct
like a folder. This organizational construct has a relationship with some unit of
executable code. For example, you could create an application called MyMobileApp to
organize and manage configuration data for a mobile application installed by your users.
# Arguments
- `name`: A name for the application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the application.
- `"Tags"`: Metadata to assign to the application. Tags help organize and categorize your
AppConfig resources. Each tag consists of a key and an optional value, both of which you
define.
"""
function create_application(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"POST",
"/applications",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_application(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"POST",
"/applications",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configuration_profile(application_id, location_uri, name)
create_configuration_profile(application_id, location_uri, name, params::Dict{String,<:Any})
Creates a configuration profile, which is information that enables AppConfig to access the
configuration source. Valid configuration sources include the following: Configuration
data in YAML, JSON, and other formats stored in the AppConfig hosted configuration store
Configuration data stored as objects in an Amazon Simple Storage Service (Amazon S3) bucket
Pipelines stored in CodePipeline Secrets stored in Secrets Manager Standard and
secure string parameters stored in Amazon Web Services Systems Manager Parameter Store
Configuration data in SSM documents stored in the Systems Manager document store A
configuration profile includes the following information: The URI location of the
configuration data. The Identity and Access Management (IAM) role that provides access to
the configuration data. A validator for the configuration data. Available validators
include either a JSON Schema or an Amazon Web Services Lambda function. For more
information, see Create a Configuration and a Configuration Profile in the AppConfig User
Guide.
# Arguments
- `application_id`: The application ID.
- `location_uri`: A URI to locate the configuration. You can specify the following: For
the AppConfig hosted configuration store and for feature flags, specify hosted. For an
Amazon Web Services Systems Manager Parameter Store parameter, specify either the parameter
name in the format ssm-parameter://<parameter name> or the ARN. For an Amazon Web
Services CodePipeline pipeline, specify the URI in the following format:
codepipeline://<pipeline name>. For an Secrets Manager secret, specify the URI in
the following format: secretsmanager://<secret name>. For an Amazon S3 object,
specify the URI in the following format: s3://<bucket>/<objectKey> . Here is an
example: s3://my-bucket/my-app/us-east-1/my-config.json For an SSM document, specify
either the document name in the format ssm-document://<document name> or the Amazon
Resource Name (ARN).
- `name`: A name for the configuration profile.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the configuration profile.
- `"KmsKeyIdentifier"`: The identifier for an Key Management Service key to encrypt new
configuration data versions in the AppConfig hosted configuration store. This attribute is
only used for hosted configuration types. The identifier can be an KMS key ID, alias, or
the Amazon Resource Name (ARN) of the key ID or alias. To encrypt data managed in other
configuration stores, see the documentation for how to specify an KMS key for that
particular service.
- `"RetrievalRoleArn"`: The ARN of an IAM role with permission to access the configuration
at the specified LocationUri. A retrieval role ARN is not required for configurations
stored in the AppConfig hosted configuration store. It is required for all other sources
that store your configuration.
- `"Tags"`: Metadata to assign to the configuration profile. Tags help organize and
categorize your AppConfig resources. Each tag consists of a key and an optional value, both
of which you define.
- `"Type"`: The type of configurations contained in the profile. AppConfig supports feature
flags and freeform configurations. We recommend you create feature flag configurations to
enable or disable new features and freeform configurations to distribute configurations to
an application. When calling this API, enter one of the following values for Type:
AWS.AppConfig.FeatureFlags AWS.Freeform
- `"Validators"`: A list of methods for validating the configuration.
"""
function create_configuration_profile(
ApplicationId, LocationUri, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles",
Dict{String,Any}("LocationUri" => LocationUri, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configuration_profile(
ApplicationId,
LocationUri,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("LocationUri" => LocationUri, "Name" => Name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment_strategy(deployment_duration_in_minutes, growth_factor, name)
create_deployment_strategy(deployment_duration_in_minutes, growth_factor, name, params::Dict{String,<:Any})
Creates a deployment strategy that defines important criteria for rolling out your
configuration to the designated targets. A deployment strategy includes the overall
duration required, a percentage of targets to receive the deployment during each interval,
an algorithm that defines how percentage grows, and bake time.
# Arguments
- `deployment_duration_in_minutes`: Total amount of time for a deployment to last.
- `growth_factor`: The percentage of targets to receive a deployed configuration during
each interval.
- `name`: A name for the deployment strategy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the deployment strategy.
- `"FinalBakeTimeInMinutes"`: Specifies the amount of time AppConfig monitors for Amazon
CloudWatch alarms after the configuration has been deployed to 100% of its targets, before
considering the deployment to be complete. If an alarm is triggered during this time,
AppConfig rolls back the deployment. You must configure permissions for AppConfig to roll
back based on CloudWatch alarms. For more information, see Configuring permissions for
rollback based on Amazon CloudWatch alarms in the AppConfig User Guide.
- `"GrowthType"`: The algorithm used to define how percentage grows over time. AppConfig
supports the following growth types: Linear: For this type, AppConfig processes the
deployment by dividing the total number of targets by the value specified for Step
percentage. For example, a linear deployment that uses a Step percentage of 10 deploys the
configuration to 10 percent of the hosts. After those deployments are complete, the system
deploys the configuration to the next 10 percent. This continues until 100% of the targets
have successfully received the configuration. Exponential: For this type, AppConfig
processes the deployment exponentially using the following formula: G*(2^N). In this
formula, G is the growth factor specified by the user and N is the number of steps until
the configuration is deployed to all targets. For example, if you specify a growth factor
of 2, then the system rolls out the configuration as follows: 2*(2^0) 2*(2^1) 2*(2^2)
Expressed numerically, the deployment rolls out as follows: 2% of the targets, 4% of the
targets, 8% of the targets, and continues until the configuration has been deployed to all
targets.
- `"ReplicateTo"`: Save the deployment strategy to a Systems Manager (SSM) document.
- `"Tags"`: Metadata to assign to the deployment strategy. Tags help organize and
categorize your AppConfig resources. Each tag consists of a key and an optional value, both
of which you define.
"""
function create_deployment_strategy(
DeploymentDurationInMinutes,
GrowthFactor,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/deploymentstrategies",
Dict{String,Any}(
"DeploymentDurationInMinutes" => DeploymentDurationInMinutes,
"GrowthFactor" => GrowthFactor,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment_strategy(
DeploymentDurationInMinutes,
GrowthFactor,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/deploymentstrategies",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DeploymentDurationInMinutes" => DeploymentDurationInMinutes,
"GrowthFactor" => GrowthFactor,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_environment(application_id, name)
create_environment(application_id, name, params::Dict{String,<:Any})
Creates an environment. For each application, you define one or more environments. An
environment is a deployment group of AppConfig targets, such as applications in a Beta or
Production environment. You can also define environments for application subcomponents such
as the Web, Mobile and Back-end components for your application. You can configure Amazon
CloudWatch alarms for each environment. The system monitors alarms during a configuration
deployment. If an alarm is triggered, the system rolls back the configuration.
# Arguments
- `application_id`: The application ID.
- `name`: A name for the environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the environment.
- `"Monitors"`: Amazon CloudWatch alarms to monitor during the deployment process.
- `"Tags"`: Metadata to assign to the environment. Tags help organize and categorize your
AppConfig resources. Each tag consists of a key and an optional value, both of which you
define.
"""
function create_environment(
ApplicationId, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/environments",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_environment(
ApplicationId,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/environments",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_extension(actions, name)
create_extension(actions, name, params::Dict{String,<:Any})
Creates an AppConfig extension. An extension augments your ability to inject logic or
behavior at different points during the AppConfig workflow of creating or deploying a
configuration. You can create your own extensions or use the Amazon Web Services authored
extensions provided by AppConfig. For an AppConfig extension that uses Lambda, you must
create a Lambda function to perform any computation and processing defined in the
extension. If you plan to create custom versions of the Amazon Web Services authored
notification extensions, you only need to specify an Amazon Resource Name (ARN) in the Uri
field for the new extension version. For a custom EventBridge notification extension,
enter the ARN of the EventBridge default events in the Uri field. For a custom Amazon SNS
notification extension, enter the ARN of an Amazon SNS topic in the Uri field. For a
custom Amazon SQS notification extension, enter the ARN of an Amazon SQS message queue in
the Uri field. For more information about extensions, see Extending workflows in the
AppConfig User Guide.
# Arguments
- `actions`: The actions defined in the extension.
- `name`: A name for the extension. Each extension name in your account must be unique.
Extension versions use the same name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: Information about the extension.
- `"Latest-Version-Number"`: You can omit this field when you create an extension. When you
create a new version, specify the most recent current version number. For example, you
create version 3, enter 2 for this field.
- `"Parameters"`: The parameters accepted by the extension. You specify parameter values
when you associate the extension to an AppConfig resource by using the
CreateExtensionAssociation API action. For Lambda extension actions, these parameters are
included in the Lambda request object.
- `"Tags"`: Adds one or more tags for the specified extension. Tags are metadata that help
you categorize resources in different ways, for example, by purpose, owner, or environment.
Each tag consists of a key and an optional value, both of which you define.
"""
function create_extension(Actions, Name; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"POST",
"/extensions",
Dict{String,Any}("Actions" => Actions, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_extension(
Actions,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/extensions",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Actions" => Actions, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_extension_association(extension_identifier, resource_identifier)
create_extension_association(extension_identifier, resource_identifier, params::Dict{String,<:Any})
When you create an extension or configure an Amazon Web Services authored extension, you
associate the extension with an AppConfig application, environment, or configuration
profile. For example, you can choose to run the AppConfig deployment events to Amazon SNS
Amazon Web Services authored extension and receive notifications on an Amazon SNS topic
anytime a configuration deployment is started for a specific application. Defining which
extension to associate with an AppConfig resource is called an extension association. An
extension association is a specified relationship between an extension and an AppConfig
resource, such as an application or a configuration profile. For more information about
extensions and associations, see Extending workflows in the AppConfig User Guide.
# Arguments
- `extension_identifier`: The name, the ID, or the Amazon Resource Name (ARN) of the
extension.
- `resource_identifier`: The ARN of an application, configuration profile, or environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExtensionVersionNumber"`: The version number of the extension. If not specified,
AppConfig uses the maximum version of the extension.
- `"Parameters"`: The parameter names and values defined in the extensions. Extension
parameters marked Required must be entered for this field.
- `"Tags"`: Adds one or more tags for the specified extension association. Tags are
metadata that help you categorize resources in different ways, for example, by purpose,
owner, or environment. Each tag consists of a key and an optional value, both of which you
define.
"""
function create_extension_association(
ExtensionIdentifier,
ResourceIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/extensionassociations",
Dict{String,Any}(
"ExtensionIdentifier" => ExtensionIdentifier,
"ResourceIdentifier" => ResourceIdentifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_extension_association(
ExtensionIdentifier,
ResourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/extensionassociations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ExtensionIdentifier" => ExtensionIdentifier,
"ResourceIdentifier" => ResourceIdentifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_hosted_configuration_version(application_id, configuration_profile_id, content, content-_type)
create_hosted_configuration_version(application_id, configuration_profile_id, content, content-_type, params::Dict{String,<:Any})
Creates a new configuration in the AppConfig hosted configuration store.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
- `content`: The content of the configuration or the configuration data.
- `content-_type`: A standard MIME type describing the format of the configuration content.
For more information, see Content-Type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the configuration.
- `"Latest-Version-Number"`: An optional locking token used to prevent race conditions from
overwriting configuration updates when creating a new version. To ensure your data is not
overwritten when creating multiple hosted configuration versions in rapid succession,
specify the version number of the latest hosted configuration version.
- `"VersionLabel"`: An optional, user-defined label for the AppConfig hosted configuration
version. This value must contain at least one non-numeric character. For example,
\"v2.2.0\".
"""
function create_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
Content,
Content_Type;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions",
Dict{String,Any}(
"Content" => Content,
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
Content,
Content_Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Content" => Content,
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_application(application_id)
delete_application(application_id, params::Dict{String,<:Any})
Deletes an application. Deleting an application does not delete a configuration from a host.
# Arguments
- `application_id`: The ID of the application to delete.
"""
function delete_application(
ApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_application(
ApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configuration_profile(application_id, configuration_profile_id)
delete_configuration_profile(application_id, configuration_profile_id, params::Dict{String,<:Any})
Deletes a configuration profile. Deleting a configuration profile does not delete a
configuration from a host.
# Arguments
- `application_id`: The application ID that includes the configuration profile you want to
delete.
- `configuration_profile_id`: The ID of the configuration profile you want to delete.
"""
function delete_configuration_profile(
ApplicationId, ConfigurationProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configuration_profile(
ApplicationId,
ConfigurationProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_deployment_strategy(deployment_strategy_id)
delete_deployment_strategy(deployment_strategy_id, params::Dict{String,<:Any})
Deletes a deployment strategy. Deleting a deployment strategy does not delete a
configuration from a host.
# Arguments
- `deployment_strategy_id`: The ID of the deployment strategy you want to delete.
"""
function delete_deployment_strategy(
DeploymentStrategyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/deployementstrategies/$(DeploymentStrategyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_deployment_strategy(
DeploymentStrategyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/deployementstrategies/$(DeploymentStrategyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_environment(application_id, environment_id)
delete_environment(application_id, environment_id, params::Dict{String,<:Any})
Deletes an environment. Deleting an environment does not delete a configuration from a host.
# Arguments
- `application_id`: The application ID that includes the environment that you want to
delete.
- `environment_id`: The ID of the environment that you want to delete.
"""
function delete_environment(
ApplicationId, EnvironmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_environment(
ApplicationId,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_extension(extension_identifier)
delete_extension(extension_identifier, params::Dict{String,<:Any})
Deletes an AppConfig extension. You must delete all associations to an extension before you
delete the extension.
# Arguments
- `extension_identifier`: The name, ID, or Amazon Resource Name (ARN) of the extension you
want to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"version"`: A specific version of an extension to delete. If omitted, the highest
version is deleted.
"""
function delete_extension(
ExtensionIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/extensions/$(ExtensionIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_extension(
ExtensionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/extensions/$(ExtensionIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_extension_association(extension_association_id)
delete_extension_association(extension_association_id, params::Dict{String,<:Any})
Deletes an extension association. This action doesn't delete extensions defined in the
association.
# Arguments
- `extension_association_id`: The ID of the extension association to delete.
"""
function delete_extension_association(
ExtensionAssociationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/extensionassociations/$(ExtensionAssociationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_extension_association(
ExtensionAssociationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/extensionassociations/$(ExtensionAssociationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_hosted_configuration_version(application_id, configuration_profile_id, version_number)
delete_hosted_configuration_version(application_id, configuration_profile_id, version_number, params::Dict{String,<:Any})
Deletes a version of a configuration from the AppConfig hosted configuration store.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
- `version_number`: The versions number to delete.
"""
function delete_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
VersionNumber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions/$(VersionNumber)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
VersionNumber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions/$(VersionNumber)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_application(application_id)
get_application(application_id, params::Dict{String,<:Any})
Retrieves information about an application.
# Arguments
- `application_id`: The ID of the application you want to get.
"""
function get_application(ApplicationId; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET",
"/applications/$(ApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_application(
ApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configuration(application, configuration, environment, client_id)
get_configuration(application, configuration, environment, client_id, params::Dict{String,<:Any})
(Deprecated) Retrieves the latest deployed configuration. Note the following important
information. This API action is deprecated. Calls to receive configuration data should
use the StartConfigurationSession and GetLatestConfiguration APIs instead.
GetConfiguration is a priced call. For more information, see Pricing.
# Arguments
- `application`: The application to get. Specify either the application name or the
application ID.
- `configuration`: The configuration to get. Specify either the configuration name or the
configuration ID.
- `environment`: The environment to get. Specify either the environment name or the
environment ID.
- `client_id`: The clientId parameter in the following command is a unique, user-specified
ID to identify the client for the configuration. This ID enables AppConfig to deploy the
configuration in intervals, as defined in the deployment strategy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"client_configuration_version"`: The configuration version returned in the most recent
GetConfiguration response. AppConfig uses the value of the ClientConfigurationVersion
parameter to identify the configuration version on your clients. If you don’t send
ClientConfigurationVersion with each call to GetConfiguration, your clients receive the
current configuration. You are charged each time your clients receive a configuration. To
avoid excess charges, we recommend you use the StartConfigurationSession and
GetLatestConfiguration APIs, which track the client configuration version on your behalf.
If you choose to continue using GetConfiguration, we recommend that you include the
ClientConfigurationVersion value with every call to GetConfiguration. The value to use for
ClientConfigurationVersion comes from the ConfigurationVersion attribute returned by
GetConfiguration when there is new or updated data, and should be saved for subsequent
calls to GetConfiguration. For more information about working with configurations, see
Retrieving the Configuration in the AppConfig User Guide.
"""
function get_configuration(
Application,
Configuration,
Environment,
client_id;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(Application)/environments/$(Environment)/configurations/$(Configuration)",
Dict{String,Any}("client_id" => client_id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configuration(
Application,
Configuration,
Environment,
client_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(Application)/environments/$(Environment)/configurations/$(Configuration)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("client_id" => client_id), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configuration_profile(application_id, configuration_profile_id)
get_configuration_profile(application_id, configuration_profile_id, params::Dict{String,<:Any})
Retrieves information about a configuration profile.
# Arguments
- `application_id`: The ID of the application that includes the configuration profile you
want to get.
- `configuration_profile_id`: The ID of the configuration profile that you want to get.
"""
function get_configuration_profile(
ApplicationId, ConfigurationProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configuration_profile(
ApplicationId,
ConfigurationProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment(application_id, deployment_number, environment_id)
get_deployment(application_id, deployment_number, environment_id, params::Dict{String,<:Any})
Retrieves information about a configuration deployment.
# Arguments
- `application_id`: The ID of the application that includes the deployment you want to get.
- `deployment_number`: The sequence number of the deployment.
- `environment_id`: The ID of the environment that includes the deployment you want to get.
"""
function get_deployment(
ApplicationId,
DeploymentNumber,
EnvironmentId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments/$(DeploymentNumber)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment(
ApplicationId,
DeploymentNumber,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments/$(DeploymentNumber)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment_strategy(deployment_strategy_id)
get_deployment_strategy(deployment_strategy_id, params::Dict{String,<:Any})
Retrieves information about a deployment strategy. A deployment strategy defines important
criteria for rolling out your configuration to the designated targets. A deployment
strategy includes the overall duration required, a percentage of targets to receive the
deployment during each interval, an algorithm that defines how percentage grows, and bake
time.
# Arguments
- `deployment_strategy_id`: The ID of the deployment strategy to get.
"""
function get_deployment_strategy(
DeploymentStrategyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/deploymentstrategies/$(DeploymentStrategyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment_strategy(
DeploymentStrategyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/deploymentstrategies/$(DeploymentStrategyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_environment(application_id, environment_id)
get_environment(application_id, environment_id, params::Dict{String,<:Any})
Retrieves information about an environment. An environment is a deployment group of
AppConfig applications, such as applications in a Production environment or in an EU_Region
environment. Each configuration deployment targets an environment. You can enable one or
more Amazon CloudWatch alarms for an environment. If an alarm is triggered during a
deployment, AppConfig roles back the configuration.
# Arguments
- `application_id`: The ID of the application that includes the environment you want to get.
- `environment_id`: The ID of the environment that you want to get.
"""
function get_environment(
ApplicationId, EnvironmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_environment(
ApplicationId,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_extension(extension_identifier)
get_extension(extension_identifier, params::Dict{String,<:Any})
Returns information about an AppConfig extension.
# Arguments
- `extension_identifier`: The name, the ID, or the Amazon Resource Name (ARN) of the
extension.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"version_number"`: The extension version number. If no version number was defined,
AppConfig uses the highest version.
"""
function get_extension(
ExtensionIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/extensions/$(ExtensionIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_extension(
ExtensionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/extensions/$(ExtensionIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_extension_association(extension_association_id)
get_extension_association(extension_association_id, params::Dict{String,<:Any})
Returns information about an AppConfig extension association. For more information about
extensions and associations, see Extending workflows in the AppConfig User Guide.
# Arguments
- `extension_association_id`: The extension association ID to get.
"""
function get_extension_association(
ExtensionAssociationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/extensionassociations/$(ExtensionAssociationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_extension_association(
ExtensionAssociationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/extensionassociations/$(ExtensionAssociationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_hosted_configuration_version(application_id, configuration_profile_id, version_number)
get_hosted_configuration_version(application_id, configuration_profile_id, version_number, params::Dict{String,<:Any})
Retrieves information about a specific configuration version.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
- `version_number`: The version.
"""
function get_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
VersionNumber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions/$(VersionNumber)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_hosted_configuration_version(
ApplicationId,
ConfigurationProfileId,
VersionNumber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions/$(VersionNumber)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_applications()
list_applications(params::Dict{String,<:Any})
Lists all applications in your Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Next token is a pagination token generated by
AppConfig to describe what page the previous List call ended on. For the first List
request, the nextToken should not be set. On subsequent calls, the nextToken parameter
should be set to the previous responses nextToken value. Use this token to get the next set
of results.
"""
function list_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET", "/applications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configuration_profiles(application_id)
list_configuration_profiles(application_id, params::Dict{String,<:Any})
Lists the configuration profiles for an application.
# Arguments
- `application_id`: The application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Use this token to get the next set of results.
- `"type"`: A filter based on the type of configurations that the configuration profile
contains. A configuration can be a feature flag or a freeform configuration.
"""
function list_configuration_profiles(
ApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_configuration_profiles(
ApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployment_strategies()
list_deployment_strategies(params::Dict{String,<:Any})
Lists deployment strategies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Use this token to get the next set of results.
"""
function list_deployment_strategies(; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET",
"/deploymentstrategies";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_deployment_strategies(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/deploymentstrategies",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployments(application_id, environment_id)
list_deployments(application_id, environment_id, params::Dict{String,<:Any})
Lists the deployments for an environment in descending deployment number order.
# Arguments
- `application_id`: The application ID.
- `environment_id`: The environment ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items that may be returned for this call. If there
are items that have not yet been returned, the response will include a non-null NextToken
that you can provide in a subsequent call to get the next set of results.
- `"next_token"`: The token returned by a prior call to this operation indicating the next
set of results to be returned. If not specified, the operation will return the first set of
results.
"""
function list_deployments(
ApplicationId, EnvironmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_deployments(
ApplicationId,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_environments(application_id)
list_environments(application_id, params::Dict{String,<:Any})
Lists the environments for an application.
# Arguments
- `application_id`: The application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Use this token to get the next set of results.
"""
function list_environments(ApplicationId; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_environments(
ApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/environments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_extension_associations()
list_extension_associations(params::Dict{String,<:Any})
Lists all AppConfig extension associations in the account. For more information about
extensions and associations, see Extending workflows in the AppConfig User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"extension_identifier"`: The name, the ID, or the Amazon Resource Name (ARN) of the
extension.
- `"extension_version_number"`: The version number for the extension defined in the
association.
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Use this token to get the next set of results
or pass null to get the first set of results.
- `"resource_identifier"`: The ARN of an application, configuration profile, or environment.
"""
function list_extension_associations(; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET",
"/extensionassociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_extension_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/extensionassociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_extensions()
list_extensions(params::Dict{String,<:Any})
Lists all custom and Amazon Web Services authored AppConfig extensions in the account. For
more information about extensions, see Extending workflows in the AppConfig User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"name"`: The extension name.
- `"next_token"`: A token to start the list. Use this token to get the next set of results.
"""
function list_extensions(; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"GET", "/extensions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_extensions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET", "/extensions", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_hosted_configuration_versions(application_id, configuration_profile_id)
list_hosted_configuration_versions(application_id, configuration_profile_id, params::Dict{String,<:Any})
Lists configurations stored in the AppConfig hosted configuration store by version.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max_results"`: The maximum number of items to return for this call. The call also
returns a token that you can specify in a subsequent call to get the next set of results.
- `"next_token"`: A token to start the list. Use this token to get the next set of results.
- `"version_label"`: An optional filter that can be used to specify the version label of an
AppConfig hosted configuration version. This parameter supports filtering by prefix using a
wildcard, for example \"v2*\". If you don't specify an asterisk at the end of the value,
only an exact match is returned.
"""
function list_hosted_configuration_versions(
ApplicationId, ConfigurationProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_hosted_configuration_versions(
ApplicationId,
ConfigurationProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/hostedconfigurationversions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieves the list of key-value tags assigned to the resource.
# Arguments
- `resource_arn`: The resource ARN.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"GET",
"/tags/$(ResourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"GET",
"/tags/$(ResourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_deployment(application_id, configuration_profile_id, configuration_version, deployment_strategy_id, environment_id)
start_deployment(application_id, configuration_profile_id, configuration_version, deployment_strategy_id, environment_id, params::Dict{String,<:Any})
Starts a deployment.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
- `configuration_version`: The configuration version to deploy. If deploying an AppConfig
hosted configuration version, you can specify either the version number or version label.
For all other configurations, you must specify the version number.
- `deployment_strategy_id`: The deployment strategy ID.
- `environment_id`: The environment ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the deployment.
- `"DynamicExtensionParameters"`: A map of dynamic extension parameter names to values to
pass to associated extensions with PRE_START_DEPLOYMENT actions.
- `"KmsKeyIdentifier"`: The KMS key identifier (key ID, key alias, or key ARN). AppConfig
uses this ID to encrypt the configuration data using a customer managed key.
- `"Tags"`: Metadata to assign to the deployment. Tags help organize and categorize your
AppConfig resources. Each tag consists of a key and an optional value, both of which you
define.
"""
function start_deployment(
ApplicationId,
ConfigurationProfileId,
ConfigurationVersion,
DeploymentStrategyId,
EnvironmentId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments",
Dict{String,Any}(
"ConfigurationProfileId" => ConfigurationProfileId,
"ConfigurationVersion" => ConfigurationVersion,
"DeploymentStrategyId" => DeploymentStrategyId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_deployment(
ApplicationId,
ConfigurationProfileId,
ConfigurationVersion,
DeploymentStrategyId,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConfigurationProfileId" => ConfigurationProfileId,
"ConfigurationVersion" => ConfigurationVersion,
"DeploymentStrategyId" => DeploymentStrategyId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_deployment(application_id, deployment_number, environment_id)
stop_deployment(application_id, deployment_number, environment_id, params::Dict{String,<:Any})
Stops a deployment. This API action works only on deployments that have a status of
DEPLOYING. This action moves the deployment to a status of ROLLED_BACK.
# Arguments
- `application_id`: The application ID.
- `deployment_number`: The sequence number of the deployment.
- `environment_id`: The environment ID.
"""
function stop_deployment(
ApplicationId,
DeploymentNumber,
EnvironmentId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments/$(DeploymentNumber)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_deployment(
ApplicationId,
DeploymentNumber,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)/deployments/$(DeploymentNumber)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns metadata to an AppConfig resource. Tags help organize and categorize your AppConfig
resources. Each tag consists of a key and an optional value, both of which you define. You
can specify a maximum of 50 tags for a resource.
# Arguments
- `resource_arn`: The ARN of the resource for which to retrieve tags.
- `tags`: The key-value string map. The valid character set is [a-zA-Z+-=._:/]. The tag key
can be up to 128 characters and must not start with aws:. The tag value can be up to 256
characters.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return appconfig(
"POST",
"/tags/$(ResourceArn)",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/tags/$(ResourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Deletes a tag key and value from an AppConfig resource.
# Arguments
- `resource_arn`: The ARN of the resource for which to remove tags.
- `tag_keys`: The tag keys to delete.
"""
function untag_resource(
ResourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"DELETE",
"/tags/$(ResourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"DELETE",
"/tags/$(ResourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application(application_id)
update_application(application_id, params::Dict{String,<:Any})
Updates an application.
# Arguments
- `application_id`: The application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the application.
- `"Name"`: The name of the application.
"""
function update_application(
ApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_application(
ApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configuration_profile(application_id, configuration_profile_id)
update_configuration_profile(application_id, configuration_profile_id, params::Dict{String,<:Any})
Updates a configuration profile.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The ID of the configuration profile.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the configuration profile.
- `"KmsKeyIdentifier"`: The identifier for a Key Management Service key to encrypt new
configuration data versions in the AppConfig hosted configuration store. This attribute is
only used for hosted configuration types. The identifier can be an KMS key ID, alias, or
the Amazon Resource Name (ARN) of the key ID or alias. To encrypt data managed in other
configuration stores, see the documentation for how to specify an KMS key for that
particular service.
- `"Name"`: The name of the configuration profile.
- `"RetrievalRoleArn"`: The ARN of an IAM role with permission to access the configuration
at the specified LocationUri.
- `"Validators"`: A list of methods for validating the configuration.
"""
function update_configuration_profile(
ApplicationId, ConfigurationProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configuration_profile(
ApplicationId,
ConfigurationProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_deployment_strategy(deployment_strategy_id)
update_deployment_strategy(deployment_strategy_id, params::Dict{String,<:Any})
Updates a deployment strategy.
# Arguments
- `deployment_strategy_id`: The deployment strategy ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DeploymentDurationInMinutes"`: Total amount of time for a deployment to last.
- `"Description"`: A description of the deployment strategy.
- `"FinalBakeTimeInMinutes"`: The amount of time that AppConfig monitors for alarms before
considering the deployment to be complete and no longer eligible for automatic rollback.
- `"GrowthFactor"`: The percentage of targets to receive a deployed configuration during
each interval.
- `"GrowthType"`: The algorithm used to define how percentage grows over time. AppConfig
supports the following growth types: Linear: For this type, AppConfig processes the
deployment by increments of the growth factor evenly distributed over the deployment time.
For example, a linear deployment that uses a growth factor of 20 initially makes the
configuration available to 20 percent of the targets. After 1/5th of the deployment time
has passed, the system updates the percentage to 40 percent. This continues until 100% of
the targets are set to receive the deployed configuration. Exponential: For this type,
AppConfig processes the deployment exponentially using the following formula: G*(2^N). In
this formula, G is the growth factor specified by the user and N is the number of steps
until the configuration is deployed to all targets. For example, if you specify a growth
factor of 2, then the system rolls out the configuration as follows: 2*(2^0) 2*(2^1)
2*(2^2) Expressed numerically, the deployment rolls out as follows: 2% of the targets, 4%
of the targets, 8% of the targets, and continues until the configuration has been deployed
to all targets.
"""
function update_deployment_strategy(
DeploymentStrategyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/deploymentstrategies/$(DeploymentStrategyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_deployment_strategy(
DeploymentStrategyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/deploymentstrategies/$(DeploymentStrategyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_environment(application_id, environment_id)
update_environment(application_id, environment_id, params::Dict{String,<:Any})
Updates an environment.
# Arguments
- `application_id`: The application ID.
- `environment_id`: The environment ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the environment.
- `"Monitors"`: Amazon CloudWatch alarms to monitor during the deployment process.
- `"Name"`: The name of the environment.
"""
function update_environment(
ApplicationId, EnvironmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_environment(
ApplicationId,
EnvironmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/applications/$(ApplicationId)/environments/$(EnvironmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_extension(extension_identifier)
update_extension(extension_identifier, params::Dict{String,<:Any})
Updates an AppConfig extension. For more information about extensions, see Extending
workflows in the AppConfig User Guide.
# Arguments
- `extension_identifier`: The name, the ID, or the Amazon Resource Name (ARN) of the
extension.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Actions"`: The actions defined in the extension.
- `"Description"`: Information about the extension.
- `"Parameters"`: One or more parameters for the actions called by the extension.
- `"VersionNumber"`: The extension version number.
"""
function update_extension(
ExtensionIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/extensions/$(ExtensionIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_extension(
ExtensionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/extensions/$(ExtensionIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_extension_association(extension_association_id)
update_extension_association(extension_association_id, params::Dict{String,<:Any})
Updates an association. For more information about extensions and associations, see
Extending workflows in the AppConfig User Guide.
# Arguments
- `extension_association_id`: The system-generated ID for the association.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Parameters"`: The parameter names and values defined in the extension.
"""
function update_extension_association(
ExtensionAssociationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfig(
"PATCH",
"/extensionassociations/$(ExtensionAssociationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_extension_association(
ExtensionAssociationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"PATCH",
"/extensionassociations/$(ExtensionAssociationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
validate_configuration(application_id, configuration_profile_id, configuration_version)
validate_configuration(application_id, configuration_profile_id, configuration_version, params::Dict{String,<:Any})
Uses the validators in a configuration profile to validate a configuration.
# Arguments
- `application_id`: The application ID.
- `configuration_profile_id`: The configuration profile ID.
- `configuration_version`: The version of the configuration to validate.
"""
function validate_configuration(
ApplicationId,
ConfigurationProfileId,
configuration_version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/validators",
Dict{String,Any}("configuration_version" => configuration_version);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function validate_configuration(
ApplicationId,
ConfigurationProfileId,
configuration_version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfig(
"POST",
"/applications/$(ApplicationId)/configurationprofiles/$(ConfigurationProfileId)/validators",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("configuration_version" => configuration_version),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 4943 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appconfigdata
using AWS.Compat
using AWS.UUIDs
"""
get_latest_configuration(configuration_token)
get_latest_configuration(configuration_token, params::Dict{String,<:Any})
Retrieves the latest deployed configuration. This API may return empty configuration data
if the client already has the latest version. For more information about this API action
and to view example CLI commands that show how to use it with the StartConfigurationSession
API action, see Retrieving the configuration in the AppConfig User Guide. Note the
following important information. Each configuration token is only valid for one call to
GetLatestConfiguration. The GetLatestConfiguration response includes a
NextPollConfigurationToken that should always replace the token used for the just-completed
call in preparation for the next one. GetLatestConfiguration is a priced call. For more
information, see Pricing.
# Arguments
- `configuration_token`: Token describing the current state of the configuration session.
To obtain a token, first call the StartConfigurationSession API. Note that every call to
GetLatestConfiguration will return a new ConfigurationToken (NextPollConfigurationToken in
the response) and must be provided to subsequent GetLatestConfiguration API calls. This
token should only be used once. To support long poll use cases, the token is valid for up
to 24 hours. If a GetLatestConfiguration call uses an expired token, the system returns
BadRequestException.
"""
function get_latest_configuration(
configuration_token; aws_config::AbstractAWSConfig=global_aws_config()
)
return appconfigdata(
"GET",
"/configuration",
Dict{String,Any}("configuration_token" => configuration_token);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_latest_configuration(
configuration_token,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfigdata(
"GET",
"/configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("configuration_token" => configuration_token),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_configuration_session(application_identifier, configuration_profile_identifier, environment_identifier)
start_configuration_session(application_identifier, configuration_profile_identifier, environment_identifier, params::Dict{String,<:Any})
Starts a configuration session used to retrieve a deployed configuration. For more
information about this API action and to view example CLI commands that show how to use it
with the GetLatestConfiguration API action, see Retrieving the configuration in the
AppConfig User Guide.
# Arguments
- `application_identifier`: The application ID or the application name.
- `configuration_profile_identifier`: The configuration profile ID or the configuration
profile name.
- `environment_identifier`: The environment ID or the environment name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RequiredMinimumPollIntervalInSeconds"`: Sets a constraint on a session. If you specify
a value of, for example, 60 seconds, then the client that established the session can't
call GetLatestConfiguration more frequently than every 60 seconds.
"""
function start_configuration_session(
ApplicationIdentifier,
ConfigurationProfileIdentifier,
EnvironmentIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfigdata(
"POST",
"/configurationsessions",
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"ConfigurationProfileIdentifier" => ConfigurationProfileIdentifier,
"EnvironmentIdentifier" => EnvironmentIdentifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_configuration_session(
ApplicationIdentifier,
ConfigurationProfileIdentifier,
EnvironmentIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appconfigdata(
"POST",
"/configurationsessions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"ConfigurationProfileIdentifier" => ConfigurationProfileIdentifier,
"EnvironmentIdentifier" => EnvironmentIdentifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 43655 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appfabric
using AWS.Compat
using AWS.UUIDs
"""
batch_get_user_access_tasks(app_bundle_identifier, task_id_list)
batch_get_user_access_tasks(app_bundle_identifier, task_id_list, params::Dict{String,<:Any})
Gets user access details in a batch request. This action polls data from the tasks that are
kicked off by the StartUserAccessTasks action.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `task_id_list`: The tasks IDs to use for the request.
"""
function batch_get_user_access_tasks(
appBundleIdentifier, taskIdList; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"POST",
"/useraccess/batchget",
Dict{String,Any}(
"appBundleIdentifier" => appBundleIdentifier, "taskIdList" => taskIdList
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_user_access_tasks(
appBundleIdentifier,
taskIdList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/useraccess/batchget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"appBundleIdentifier" => appBundleIdentifier, "taskIdList" => taskIdList
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
connect_app_authorization(app_authorization_identifier, app_bundle_identifier)
connect_app_authorization(app_authorization_identifier, app_bundle_identifier, params::Dict{String,<:Any})
Establishes a connection between Amazon Web Services AppFabric and an application, which
allows AppFabric to call the APIs of the application.
# Arguments
- `app_authorization_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the app authorization to use for the request.
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle that contains the app authorization to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authRequest"`: Contains OAuth2 authorization information. This is required if the app
authorization for the request is configured with an OAuth2 (oauth2) authorization type.
"""
function connect_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)/connect";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function connect_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)/connect",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_authorization(app, app_bundle_identifier, auth_type, credential, tenant)
create_app_authorization(app, app_bundle_identifier, auth_type, credential, tenant, params::Dict{String,<:Any})
Creates an app authorization within an app bundle, which allows AppFabric to connect to an
application.
# Arguments
- `app`: The name of the application. Valid values are: SLACK ASANA JIRA
M365 M365AUDITLOGS ZOOM ZENDESK OKTA GOOGLE DROPBOX SMARTSHEET
CISCO
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `auth_type`: The authorization type for the app authorization.
- `credential`: Contains credentials for the application, such as an API key or OAuth2
client ID and secret. Specify credentials that match the authorization type for your
request. For example, if the authorization type for your request is OAuth2 (oauth2), then
you should provide only the OAuth2 credentials.
- `tenant`: Contains information about an application tenant, such as the application
display name and identifier.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Specifies a unique, case-sensitive identifier that you provide to ensure
the idempotency of the request. This lets you safely retry the request without accidentally
performing the same operation a second time. Passing the same value to a later call to an
operation requires that you also pass the same value for all other parameters. We recommend
that you use a UUID type of value. If you don't provide this value, then Amazon Web
Services generates a random one for you. If you retry the operation with the same
ClientToken, but with different parameters, the retry fails with an
IdempotentParameterMismatch error.
- `"tags"`: A map of the key-value pairs of the tag or tags to assign to the resource.
"""
function create_app_authorization(
app,
appBundleIdentifier,
authType,
credential,
tenant;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/appauthorizations",
Dict{String,Any}(
"app" => app,
"authType" => authType,
"credential" => credential,
"tenant" => tenant,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_authorization(
app,
appBundleIdentifier,
authType,
credential,
tenant,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/appauthorizations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"app" => app,
"authType" => authType,
"credential" => credential,
"tenant" => tenant,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_bundle()
create_app_bundle(params::Dict{String,<:Any})
Creates an app bundle to collect data from an application using AppFabric.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Specifies a unique, case-sensitive identifier that you provide to ensure
the idempotency of the request. This lets you safely retry the request without accidentally
performing the same operation a second time. Passing the same value to a later call to an
operation requires that you also pass the same value for all other parameters. We recommend
that you use a UUID type of value. If you don't provide this value, then Amazon Web
Services generates a random one for you. If you retry the operation with the same
ClientToken, but with different parameters, the retry fails with an
IdempotentParameterMismatch error.
- `"customerManagedKeyIdentifier"`: The Amazon Resource Name (ARN) of the Key Management
Service (KMS) key to use to encrypt the application data. If this is not specified, an
Amazon Web Services owned key is used for encryption.
- `"tags"`: A map of the key-value pairs of the tag or tags to assign to the resource.
"""
function create_app_bundle(; aws_config::AbstractAWSConfig=global_aws_config())
return appfabric(
"POST",
"/appbundles",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_bundle(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"POST",
"/appbundles",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_ingestion(app, app_bundle_identifier, ingestion_type, tenant_id)
create_ingestion(app, app_bundle_identifier, ingestion_type, tenant_id, params::Dict{String,<:Any})
Creates a data ingestion for an application.
# Arguments
- `app`: The name of the application. Valid values are: SLACK ASANA JIRA
M365 M365AUDITLOGS ZOOM ZENDESK OKTA GOOGLE DROPBOX SMARTSHEET
CISCO
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_type`: The ingestion type.
- `tenant_id`: The ID of the application tenant.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Specifies a unique, case-sensitive identifier that you provide to ensure
the idempotency of the request. This lets you safely retry the request without accidentally
performing the same operation a second time. Passing the same value to a later call to an
operation requires that you also pass the same value for all other parameters. We recommend
that you use a UUID type of value. If you don't provide this value, then Amazon Web
Services generates a random one for you. If you retry the operation with the same
ClientToken, but with different parameters, the retry fails with an
IdempotentParameterMismatch error.
- `"tags"`: A map of the key-value pairs of the tag or tags to assign to the resource.
"""
function create_ingestion(
app,
appBundleIdentifier,
ingestionType,
tenantId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions",
Dict{String,Any}(
"app" => app,
"ingestionType" => ingestionType,
"tenantId" => tenantId,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_ingestion(
app,
appBundleIdentifier,
ingestionType,
tenantId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"app" => app,
"ingestionType" => ingestionType,
"tenantId" => tenantId,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_ingestion_destination(app_bundle_identifier, destination_configuration, ingestion_identifier, processing_configuration)
create_ingestion_destination(app_bundle_identifier, destination_configuration, ingestion_identifier, processing_configuration, params::Dict{String,<:Any})
Creates an ingestion destination, which specifies how an application's ingested data is
processed by Amazon Web Services AppFabric and where it's delivered.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `destination_configuration`: Contains information about the destination of ingested data.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
- `processing_configuration`: Contains information about how ingested data is processed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Specifies a unique, case-sensitive identifier that you provide to ensure
the idempotency of the request. This lets you safely retry the request without accidentally
performing the same operation a second time. Passing the same value to a later call to an
operation requires that you also pass the same value for all other parameters. We recommend
that you use a UUID type of value. If you don't provide this value, then Amazon Web
Services generates a random one for you. If you retry the operation with the same
ClientToken, but with different parameters, the retry fails with an
IdempotentParameterMismatch error.
- `"tags"`: A map of the key-value pairs of the tag or tags to assign to the resource.
"""
function create_ingestion_destination(
appBundleIdentifier,
destinationConfiguration,
ingestionIdentifier,
processingConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations",
Dict{String,Any}(
"destinationConfiguration" => destinationConfiguration,
"processingConfiguration" => processingConfiguration,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_ingestion_destination(
appBundleIdentifier,
destinationConfiguration,
ingestionIdentifier,
processingConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationConfiguration" => destinationConfiguration,
"processingConfiguration" => processingConfiguration,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_authorization(app_authorization_identifier, app_bundle_identifier)
delete_app_authorization(app_authorization_identifier, app_bundle_identifier, params::Dict{String,<:Any})
Deletes an app authorization. You must delete the associated ingestion before you can
delete an app authorization.
# Arguments
- `app_authorization_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the app authorization to use for the request.
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
"""
function delete_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_bundle(app_bundle_identifier)
delete_app_bundle(app_bundle_identifier, params::Dict{String,<:Any})
Deletes an app bundle. You must delete all associated app authorizations before you can
delete an app bundle.
# Arguments
- `app_bundle_identifier`: The ID or Amazon Resource Name (ARN) of the app bundle that
needs to be deleted.
"""
function delete_app_bundle(
appBundleIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_bundle(
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_ingestion(app_bundle_identifier, ingestion_identifier)
delete_ingestion(app_bundle_identifier, ingestion_identifier, params::Dict{String,<:Any})
Deletes an ingestion. You must stop (disable) the ingestion and you must delete all
associated ingestion destinations before you can delete an app ingestion.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function delete_ingestion(
appBundleIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_ingestion(
appBundleIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_ingestion_destination(app_bundle_identifier, ingestion_destination_identifier, ingestion_identifier)
delete_ingestion_destination(app_bundle_identifier, ingestion_destination_identifier, ingestion_identifier, params::Dict{String,<:Any})
Deletes an ingestion destination. This deletes the association between an ingestion and
it's destination. It doesn't delete previously ingested data or the storage destination,
such as the Amazon S3 bucket where the data is delivered. If the ingestion destination is
deleted while the associated ingestion is enabled, the ingestion will fail and is
eventually disabled.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_destination_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the ingestion destination to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function delete_ingestion_destination(
appBundleIdentifier,
ingestionDestinationIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_ingestion_destination(
appBundleIdentifier,
ingestionDestinationIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app_authorization(app_authorization_identifier, app_bundle_identifier)
get_app_authorization(app_authorization_identifier, app_bundle_identifier, params::Dict{String,<:Any})
Returns information about an app authorization.
# Arguments
- `app_authorization_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the app authorization to use for the request.
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
"""
function get_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app_bundle(app_bundle_identifier)
get_app_bundle(app_bundle_identifier, params::Dict{String,<:Any})
Returns information about an app bundle.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
"""
function get_app_bundle(
appBundleIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_app_bundle(
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_ingestion(app_bundle_identifier, ingestion_identifier)
get_ingestion(app_bundle_identifier, ingestion_identifier, params::Dict{String,<:Any})
Returns information about an ingestion.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function get_ingestion(
appBundleIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_ingestion(
appBundleIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_ingestion_destination(app_bundle_identifier, ingestion_destination_identifier, ingestion_identifier)
get_ingestion_destination(app_bundle_identifier, ingestion_destination_identifier, ingestion_identifier, params::Dict{String,<:Any})
Returns information about an ingestion destination.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_destination_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the ingestion destination to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function get_ingestion_destination(
appBundleIdentifier,
ingestionDestinationIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_ingestion_destination(
appBundleIdentifier,
ingestionDestinationIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_authorizations(app_bundle_identifier)
list_app_authorizations(app_bundle_identifier, params::Dict{String,<:Any})
Returns a list of all app authorizations configured for an app bundle.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that are returned per call. You can use
nextToken to obtain further pages of results. This is only an upper limit. The actual
number of results returned per call might be fewer than the specified maximum.
- `"nextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged. Each
pagination token expires after 24 hours. Using an expired pagination token will return an
HTTP 400 InvalidToken error.
"""
function list_app_authorizations(
appBundleIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/appauthorizations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_authorizations(
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/appauthorizations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_bundles()
list_app_bundles(params::Dict{String,<:Any})
Returns a list of app bundles.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that are returned per call. You can use
nextToken to obtain further pages of results. This is only an upper limit. The actual
number of results returned per call might be fewer than the specified maximum.
- `"nextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged. Each
pagination token expires after 24 hours. Using an expired pagination token will return an
HTTP 400 InvalidToken error.
"""
function list_app_bundles(; aws_config::AbstractAWSConfig=global_aws_config())
return appfabric(
"GET", "/appbundles"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_app_bundles(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"GET", "/appbundles", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_ingestion_destinations(app_bundle_identifier, ingestion_identifier)
list_ingestion_destinations(app_bundle_identifier, ingestion_identifier, params::Dict{String,<:Any})
Returns a list of all ingestion destinations configured for an ingestion.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that are returned per call. You can use
nextToken to obtain further pages of results. This is only an upper limit. The actual
number of results returned per call might be fewer than the specified maximum.
- `"nextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged. Each
pagination token expires after 24 hours. Using an expired pagination token will return an
HTTP 400 InvalidToken error.
"""
function list_ingestion_destinations(
appBundleIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_ingestion_destinations(
appBundleIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_ingestions(app_bundle_identifier)
list_ingestions(app_bundle_identifier, params::Dict{String,<:Any})
Returns a list of all ingestions configured for an app bundle.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that are returned per call. You can use
nextToken to obtain further pages of results. This is only an upper limit. The actual
number of results returned per call might be fewer than the specified maximum.
- `"nextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged. Each
pagination token expires after 24 hours. Using an expired pagination token will return an
HTTP 400 InvalidToken error.
"""
function list_ingestions(
appBundleIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_ingestions(
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/appbundles/$(appBundleIdentifier)/ingestions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource for which you want to
retrieve tags.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_ingestion(app_bundle_identifier, ingestion_identifier)
start_ingestion(app_bundle_identifier, ingestion_identifier, params::Dict{String,<:Any})
Starts (enables) an ingestion, which collects data from an application.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function start_ingestion(
appBundleIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/start";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_ingestion(
appBundleIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/start",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_user_access_tasks(app_bundle_identifier, email)
start_user_access_tasks(app_bundle_identifier, email, params::Dict{String,<:Any})
Starts the tasks to search user access status for a specific email address. The tasks are
stopped when the user access status data is found. The tasks are terminated when the API
calls to the application time out.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `email`: The email address of the target user.
"""
function start_user_access_tasks(
appBundleIdentifier, email; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"POST",
"/useraccess/start",
Dict{String,Any}("appBundleIdentifier" => appBundleIdentifier, "email" => email);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_user_access_tasks(
appBundleIdentifier,
email,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/useraccess/start",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"appBundleIdentifier" => appBundleIdentifier, "email" => email
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_ingestion(app_bundle_identifier, ingestion_identifier)
stop_ingestion(app_bundle_identifier, ingestion_identifier, params::Dict{String,<:Any})
Stops (disables) an ingestion.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function stop_ingestion(
appBundleIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_ingestion(
appBundleIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns one or more tags (key-value pairs) to the specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to tag.
- `tags`: A map of the key-value pairs of the tag or tags to assign to the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return appfabric(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag or tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to untag.
- `tag_keys`: The keys of the key-value pairs for the tag or tags you want to remove from
the specified resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appfabric(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_authorization(app_authorization_identifier, app_bundle_identifier)
update_app_authorization(app_authorization_identifier, app_bundle_identifier, params::Dict{String,<:Any})
Updates an app authorization within an app bundle, which allows AppFabric to connect to an
application. If the app authorization was in a connected state, updating the app
authorization will set it back to a PendingConnect state.
# Arguments
- `app_authorization_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the app authorization to use for the request.
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"credential"`: Contains credentials for the application, such as an API key or OAuth2
client ID and secret. Specify credentials that match the authorization type of the app
authorization to update. For example, if the authorization type of the app authorization is
OAuth2 (oauth2), then you should provide only the OAuth2 credentials.
- `"tenant"`: Contains information about an application tenant, such as the application
display name and identifier.
"""
function update_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"PATCH",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_authorization(
appAuthorizationIdentifier,
appBundleIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"PATCH",
"/appbundles/$(appBundleIdentifier)/appauthorizations/$(appAuthorizationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_ingestion_destination(app_bundle_identifier, destination_configuration, ingestion_destination_identifier, ingestion_identifier)
update_ingestion_destination(app_bundle_identifier, destination_configuration, ingestion_destination_identifier, ingestion_identifier, params::Dict{String,<:Any})
Updates an ingestion destination, which specifies how an application's ingested data is
processed by Amazon Web Services AppFabric and where it's delivered.
# Arguments
- `app_bundle_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the app bundle to use for the request.
- `destination_configuration`: Contains information about the destination of ingested data.
- `ingestion_destination_identifier`: The Amazon Resource Name (ARN) or Universal Unique
Identifier (UUID) of the ingestion destination to use for the request.
- `ingestion_identifier`: The Amazon Resource Name (ARN) or Universal Unique Identifier
(UUID) of the ingestion to use for the request.
"""
function update_ingestion_destination(
appBundleIdentifier,
destinationConfiguration,
ingestionDestinationIdentifier,
ingestionIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"PATCH",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)",
Dict{String,Any}("destinationConfiguration" => destinationConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_ingestion_destination(
appBundleIdentifier,
destinationConfiguration,
ingestionDestinationIdentifier,
ingestionIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appfabric(
"PATCH",
"/appbundles/$(appBundleIdentifier)/ingestions/$(ingestionIdentifier)/ingestiondestinations/$(ingestionDestinationIdentifier)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("destinationConfiguration" => destinationConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 48954 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appflow
using AWS.Compat
using AWS.UUIDs
"""
cancel_flow_executions(flow_name)
cancel_flow_executions(flow_name, params::Dict{String,<:Any})
Cancels active runs for a flow. You can cancel all of the active runs for a flow, or you
can cancel specific runs by providing their IDs. You can cancel a flow run only when the
run is in progress. You can't cancel a run that has already completed or failed. You also
can't cancel a run that's scheduled to occur but hasn't started yet. To prevent a scheduled
run, you can deactivate the flow with the StopFlow action. You cannot resume a run after
you cancel it. When you send your request, the status for each run becomes CancelStarted.
When the cancellation completes, the status becomes Canceled. When you cancel a run, you
still incur charges for any data that the run already processed before the cancellation. If
the run had already written some data to the flow destination, then that data remains in
the destination. If you configured the flow to use a batch API (such as the Salesforce Bulk
API 2.0), then the run will finish reading or writing its entire batch of data after the
cancellation. For these operations, the data processing charges for Amazon AppFlow apply.
For the pricing information, see Amazon AppFlow pricing.
# Arguments
- `flow_name`: The name of a flow with active runs that you want to cancel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"executionIds"`: The ID of each active run to cancel. These runs must belong to the flow
you specify in your request. If you omit this parameter, your request ends all active runs
that belong to the flow.
"""
function cancel_flow_executions(flowName; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/cancel-flow-executions",
Dict{String,Any}("flowName" => flowName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_flow_executions(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/cancel-flow-executions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("flowName" => flowName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_connector_profile(connection_mode, connector_profile_config, connector_profile_name, connector_type)
create_connector_profile(connection_mode, connector_profile_config, connector_profile_name, connector_type, params::Dict{String,<:Any})
Creates a new connector profile associated with your Amazon Web Services account. There is
a soft quota of 100 connector profiles per Amazon Web Services account. If you need more
connector profiles than this quota allows, you can submit a request to the Amazon AppFlow
team through the Amazon AppFlow support channel. In each connector profile that you create,
you can provide the credentials and properties for only one connector.
# Arguments
- `connection_mode`: Indicates the connection mode and specifies whether it is public or
private. Private flows use Amazon Web Services PrivateLink to route data over Amazon Web
Services infrastructure without exposing it to the public internet.
- `connector_profile_config`: Defines the connector-specific configuration and
credentials.
- `connector_profile_name`: The name of the connector profile. The name is unique for each
ConnectorProfile in your Amazon Web Services account.
- `connector_type`: The type of connector, such as Salesforce, Amplitude, and so on.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
CreateConnectorProfile request completes only once. You choose the value to pass. For
example, if you don't receive a response from your request, you can safely retry the
request with the same clientToken parameter value. If you omit a clientToken value, the
Amazon Web Services SDK that you are using inserts a value for you. This way, the SDK can
safely retry requests multiple times after a network error. You must provide your own value
for other use cases. If you specify input parameters that differ from your first request,
an error occurs. If you use a different value for clientToken, Amazon AppFlow considers it
a new call to CreateConnectorProfile. The token is active for 8 hours.
- `"connectorLabel"`: The label of the connector. The label is unique for each
ConnectorRegistration in your Amazon Web Services account. Only needed if calling for
CUSTOMCONNECTOR connector type/.
- `"kmsArn"`: The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you
provide for encryption. This is required if you do not want to use the Amazon
AppFlow-managed KMS key. If you don't provide anything here, Amazon AppFlow uses the Amazon
AppFlow-managed KMS key.
"""
function create_connector_profile(
connectionMode,
connectorProfileConfig,
connectorProfileName,
connectorType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/create-connector-profile",
Dict{String,Any}(
"connectionMode" => connectionMode,
"connectorProfileConfig" => connectorProfileConfig,
"connectorProfileName" => connectorProfileName,
"connectorType" => connectorType,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_connector_profile(
connectionMode,
connectorProfileConfig,
connectorProfileName,
connectorType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/create-connector-profile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"connectionMode" => connectionMode,
"connectorProfileConfig" => connectorProfileConfig,
"connectorProfileName" => connectorProfileName,
"connectorType" => connectorType,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_flow(destination_flow_config_list, flow_name, source_flow_config, tasks, trigger_config)
create_flow(destination_flow_config_list, flow_name, source_flow_config, tasks, trigger_config, params::Dict{String,<:Any})
Enables your application to create a new flow using Amazon AppFlow. You must create a
connector profile before calling this API. Please note that the Request Syntax below shows
syntax for multiple destinations, however, you can only transfer data to one item in this
list at a time. Amazon AppFlow does not currently support flows to multiple destinations at
once.
# Arguments
- `destination_flow_config_list`: The configuration that controls how Amazon AppFlow
places data in the destination connector.
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
- `source_flow_config`: The configuration that controls how Amazon AppFlow retrieves data
from the source connector.
- `tasks`: A list of tasks that Amazon AppFlow performs while transferring the data in the
flow run.
- `trigger_config`: The trigger settings that determine how and when the flow runs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
CreateFlow request completes only once. You choose the value to pass. For example, if you
don't receive a response from your request, you can safely retry the request with the same
clientToken parameter value. If you omit a clientToken value, the Amazon Web Services SDK
that you are using inserts a value for you. This way, the SDK can safely retry requests
multiple times after a network error. You must provide your own value for other use cases.
If you specify input parameters that differ from your first request, an error occurs. If
you use a different value for clientToken, Amazon AppFlow considers it a new call to
CreateFlow. The token is active for 8 hours.
- `"description"`: A description of the flow you want to create.
- `"kmsArn"`: The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you
provide for encryption. This is required if you do not want to use the Amazon
AppFlow-managed KMS key. If you don't provide anything here, Amazon AppFlow uses the Amazon
AppFlow-managed KMS key.
- `"metadataCatalogConfig"`: Specifies the configuration that Amazon AppFlow uses when it
catalogs the data that's transferred by the associated flow. When Amazon AppFlow catalogs
the data from a flow, it stores metadata in a data catalog.
- `"tags"`: The tags used to organize, track, or control access for your flow.
"""
function create_flow(
destinationFlowConfigList,
flowName,
sourceFlowConfig,
tasks,
triggerConfig;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/create-flow",
Dict{String,Any}(
"destinationFlowConfigList" => destinationFlowConfigList,
"flowName" => flowName,
"sourceFlowConfig" => sourceFlowConfig,
"tasks" => tasks,
"triggerConfig" => triggerConfig,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_flow(
destinationFlowConfigList,
flowName,
sourceFlowConfig,
tasks,
triggerConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/create-flow",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationFlowConfigList" => destinationFlowConfigList,
"flowName" => flowName,
"sourceFlowConfig" => sourceFlowConfig,
"tasks" => tasks,
"triggerConfig" => triggerConfig,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_connector_profile(connector_profile_name)
delete_connector_profile(connector_profile_name, params::Dict{String,<:Any})
Enables you to delete an existing connector profile.
# Arguments
- `connector_profile_name`: The name of the connector profile. The name is unique for each
ConnectorProfile in your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"forceDelete"`: Indicates whether Amazon AppFlow should delete the profile, even if it
is currently in use in one or more flows.
"""
function delete_connector_profile(
connectorProfileName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/delete-connector-profile",
Dict{String,Any}("connectorProfileName" => connectorProfileName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_connector_profile(
connectorProfileName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/delete-connector-profile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("connectorProfileName" => connectorProfileName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_flow(flow_name)
delete_flow(flow_name, params::Dict{String,<:Any})
Enables your application to delete an existing flow. Before deleting the flow, Amazon
AppFlow validates the request by checking the flow configuration and status. You can delete
flows one at a time.
# Arguments
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"forceDelete"`: Indicates whether Amazon AppFlow should delete the flow, even if it is
currently in use.
"""
function delete_flow(flowName; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/delete-flow",
Dict{String,Any}("flowName" => flowName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_flow(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/delete-flow",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("flowName" => flowName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_connector(connector_type)
describe_connector(connector_type, params::Dict{String,<:Any})
Describes the given custom connector registered in your Amazon Web Services account. This
API can be used for custom connectors that are registered in your account and also for
Amazon authored connectors.
# Arguments
- `connector_type`: The connector type, such as CUSTOMCONNECTOR, Saleforce, Marketo. Please
choose CUSTOMCONNECTOR for Lambda based custom connectors.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"connectorLabel"`: The label of the connector. The label is unique for each
ConnectorRegistration in your Amazon Web Services account. Only needed if calling for
CUSTOMCONNECTOR connector type/.
"""
function describe_connector(
connectorType; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/describe-connector",
Dict{String,Any}("connectorType" => connectorType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_connector(
connectorType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/describe-connector",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("connectorType" => connectorType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_connector_entity(connector_entity_name)
describe_connector_entity(connector_entity_name, params::Dict{String,<:Any})
Provides details regarding the entity used with the connector, with a description of the
data model for each field in that entity.
# Arguments
- `connector_entity_name`: The entity name for that connector.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiVersion"`: The version of the API that's used by the connector.
- `"connectorProfileName"`: The name of the connector profile. The name is unique for each
ConnectorProfile in the Amazon Web Services account.
- `"connectorType"`: The type of connector application, such as Salesforce, Amplitude, and
so on.
"""
function describe_connector_entity(
connectorEntityName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/describe-connector-entity",
Dict{String,Any}("connectorEntityName" => connectorEntityName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_connector_entity(
connectorEntityName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/describe-connector-entity",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("connectorEntityName" => connectorEntityName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_connector_profiles()
describe_connector_profiles(params::Dict{String,<:Any})
Returns a list of connector-profile details matching the provided connector-profile names
and connector-types. Both input lists are optional, and you can use them to filter the
result. If no names or connector-types are provided, returns all connector profiles in a
paginated form. If there is no match, this operation returns an empty list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"connectorLabel"`: The name of the connector. The name is unique for each
ConnectorRegistration in your Amazon Web Services account. Only needed if calling for
CUSTOMCONNECTOR connector type/.
- `"connectorProfileNames"`: The name of the connector profile. The name is unique for
each ConnectorProfile in the Amazon Web Services account.
- `"connectorType"`: The type of connector, such as Salesforce, Amplitude, and so on.
- `"maxResults"`: Specifies the maximum number of items that should be returned in the
result set. The default for maxResults is 20 (for all paginated API operations).
- `"nextToken"`: The pagination token for the next page of data.
"""
function describe_connector_profiles(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/describe-connector-profiles";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_connector_profiles(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/describe-connector-profiles",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_connectors()
describe_connectors(params::Dict{String,<:Any})
Describes the connectors vended by Amazon AppFlow for specified connector types. If you
don't specify a connector type, this operation describes all connectors vended by Amazon
AppFlow. If there are more connectors than can be returned in one page, the response
contains a nextToken object, which can be be passed in to the next call to the
DescribeConnectors API operation to retrieve the next page.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"connectorTypes"`: The type of connector, such as Salesforce, Amplitude, and so on.
- `"maxResults"`: The maximum number of items that should be returned in the result set.
The default is 20.
- `"nextToken"`: The pagination token for the next page of data.
"""
function describe_connectors(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/describe-connectors";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_connectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/describe-connectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_flow(flow_name)
describe_flow(flow_name, params::Dict{String,<:Any})
Provides a description of the specified flow.
# Arguments
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
"""
function describe_flow(flowName; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/describe-flow",
Dict{String,Any}("flowName" => flowName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_flow(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/describe-flow",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("flowName" => flowName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_flow_execution_records(flow_name)
describe_flow_execution_records(flow_name, params::Dict{String,<:Any})
Fetches the execution history of the flow.
# Arguments
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of items that should be returned in the
result set. The default for maxResults is 20 (for all paginated API operations).
- `"nextToken"`: The pagination token for the next page of data.
"""
function describe_flow_execution_records(
flowName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/describe-flow-execution-records",
Dict{String,Any}("flowName" => flowName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_flow_execution_records(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/describe-flow-execution-records",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("flowName" => flowName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_connector_entities()
list_connector_entities(params::Dict{String,<:Any})
Returns the list of available connector entities supported by Amazon AppFlow. For example,
you can query Salesforce for Account and Opportunity entities, or query ServiceNow for the
Incident entity.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiVersion"`: The version of the API that's used by the connector.
- `"connectorProfileName"`: The name of the connector profile. The name is unique for each
ConnectorProfile in the Amazon Web Services account, and is used to query the downstream
connector.
- `"connectorType"`: The type of connector, such as Salesforce, Amplitude, and so on.
- `"entitiesPath"`: This optional parameter is specific to connector implementation. Some
connectors support multiple levels or categories of entities. You can find out the list of
roots for such providers by sending a request without the entitiesPath parameter. If the
connector supports entities at different roots, this initial request returns the list of
roots. Otherwise, this request returns all entities supported by the provider.
- `"maxResults"`: The maximum number of items that the operation returns in the response.
- `"nextToken"`: A token that was provided by your prior ListConnectorEntities operation if
the response was too big for the page size. You specify this token to get the next page of
results in paginated response.
"""
function list_connector_entities(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/list-connector-entities";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_connector_entities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/list-connector-entities",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_connectors()
list_connectors(params::Dict{String,<:Any})
Returns the list of all registered custom connectors in your Amazon Web Services account.
This API lists only custom connectors registered in this account, not the Amazon Web
Services authored connectors.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of items that should be returned in the
result set. The default for maxResults is 20 (for all paginated API operations).
- `"nextToken"`: The pagination token for the next page of data.
"""
function list_connectors(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST", "/list-connectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_connectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/list-connectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_flows()
list_flows(params::Dict{String,<:Any})
Lists all of the flows associated with your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of items that should be returned in the
result set.
- `"nextToken"`: The pagination token for next page of data.
"""
function list_flows(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST", "/list-flows"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_flows(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/list-flows",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieves the tags that are associated with a specified flow.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the specified flow.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_connector()
register_connector(params::Dict{String,<:Any})
Registers a new custom connector with your Amazon Web Services account. Before you can
register the connector, you must deploy the associated AWS lambda function in your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
RegisterConnector request completes only once. You choose the value to pass. For example,
if you don't receive a response from your request, you can safely retry the request with
the same clientToken parameter value. If you omit a clientToken value, the Amazon Web
Services SDK that you are using inserts a value for you. This way, the SDK can safely retry
requests multiple times after a network error. You must provide your own value for other
use cases. If you specify input parameters that differ from your first request, an error
occurs. If you use a different value for clientToken, Amazon AppFlow considers it a new
call to RegisterConnector. The token is active for 8 hours.
- `"connectorLabel"`: The name of the connector. The name is unique for each
ConnectorRegistration in your Amazon Web Services account.
- `"connectorProvisioningConfig"`: The provisioning type of the connector. Currently the
only supported value is LAMBDA.
- `"connectorProvisioningType"`: The provisioning type of the connector. Currently the only
supported value is LAMBDA.
- `"description"`: A description about the connector that's being registered.
"""
function register_connector(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/register-connector",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_connector(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/register-connector",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
reset_connector_metadata_cache()
reset_connector_metadata_cache(params::Dict{String,<:Any})
Resets metadata about your connector entities that Amazon AppFlow stored in its cache. Use
this action when you want Amazon AppFlow to return the latest information about the data
that you have in a source application. Amazon AppFlow returns metadata about your entities
when you use the ListConnectorEntities or DescribeConnectorEntities actions. Following
these actions, Amazon AppFlow caches the metadata to reduce the number of API requests that
it must send to the source application. Amazon AppFlow automatically resets the cache once
every hour, but you can use this action when you want to get the latest metadata right away.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiVersion"`: The API version that you specified in the connector profile that you’re
resetting cached metadata for. You must use this parameter only if the connector supports
multiple API versions or if the connector type is CustomConnector. To look up how many
versions a connector supports, use the DescribeConnectors action. In the response, find the
value that Amazon AppFlow returns for the connectorVersion parameter. To look up the
connector type, use the DescribeConnectorProfiles action. In the response, find the value
that Amazon AppFlow returns for the connectorType parameter. To look up the API version
that you specified in a connector profile, use the DescribeConnectorProfiles action.
- `"connectorEntityName"`: Use this parameter if you want to reset cached metadata about
the details for an individual entity. If you don't include this parameter in your request,
Amazon AppFlow only resets cached metadata about entity names, not entity details.
- `"connectorProfileName"`: The name of the connector profile that you want to reset cached
metadata for. You can omit this parameter if you're resetting the cache for any of the
following connectors: Amazon Connect, Amazon EventBridge, Amazon Lookout for Metrics,
Amazon S3, or Upsolver. If you're resetting the cache for any other connector, you must
include this parameter in your request.
- `"connectorType"`: The type of connector to reset cached metadata for. You must include
this parameter in your request if you're resetting the cache for any of the following
connectors: Amazon Connect, Amazon EventBridge, Amazon Lookout for Metrics, Amazon S3, or
Upsolver. If you're resetting the cache for any other connector, you can omit this
parameter from your request.
- `"entitiesPath"`: Use this parameter only if you’re resetting the cached metadata about
a nested entity. Only some connectors support nested entities. A nested entity is one that
has another entity as a parent. To use this parameter, specify the name of the parent
entity. To look up the parent-child relationship of entities, you can send a
ListConnectorEntities request that omits the entitiesPath parameter. Amazon AppFlow will
return a list of top-level entities. For each one, it indicates whether the entity has
nested entities. Then, in a subsequent ListConnectorEntities request, you can specify a
parent entity name for the entitiesPath parameter. Amazon AppFlow will return a list of the
child entities for that parent.
"""
function reset_connector_metadata_cache(; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/reset-connector-metadata-cache";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function reset_connector_metadata_cache(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/reset-connector-metadata-cache",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_flow(flow_name)
start_flow(flow_name, params::Dict{String,<:Any})
Activates an existing flow. For on-demand flows, this operation runs the flow immediately.
For schedule and event-triggered flows, this operation activates the flow.
# Arguments
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
StartFlow request completes only once. You choose the value to pass. For example, if you
don't receive a response from your request, you can safely retry the request with the same
clientToken parameter value. If you omit a clientToken value, the Amazon Web Services SDK
that you are using inserts a value for you. This way, the SDK can safely retry requests
multiple times after a network error. You must provide your own value for other use cases.
If you specify input parameters that differ from your first request, an error occurs for
flows that run on a schedule or based on an event. However, the error doesn't occur for
flows that run on demand. You set the conditions that initiate your flow for the
triggerConfig parameter. If you use a different value for clientToken, Amazon AppFlow
considers it a new call to StartFlow. The token is active for 8 hours.
"""
function start_flow(flowName; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/start-flow",
Dict{String,Any}("flowName" => flowName, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_flow(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/start-flow",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("flowName" => flowName, "clientToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_flow(flow_name)
stop_flow(flow_name, params::Dict{String,<:Any})
Deactivates the existing flow. For on-demand flows, this operation returns an
unsupportedOperationException error message. For schedule and event-triggered flows, this
operation deactivates the flow.
# Arguments
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
"""
function stop_flow(flowName; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/stop-flow",
Dict{String,Any}("flowName" => flowName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_flow(
flowName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/stop-flow",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("flowName" => flowName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Applies a tag to the specified flow.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the flow that you want to tag.
- `tags`: The tags used to organize, track, or control access for your flow.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return appflow(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
unregister_connector(connector_label)
unregister_connector(connector_label, params::Dict{String,<:Any})
Unregisters the custom connector registered in your account that matches the connector
label provided in the request.
# Arguments
- `connector_label`: The label of the connector. The label is unique for each
ConnectorRegistration in your Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"forceDelete"`: Indicates whether Amazon AppFlow should unregister the connector, even
if it is currently in use in one or more connector profiles. The default value is false.
"""
function unregister_connector(
connectorLabel; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/unregister-connector",
Dict{String,Any}("connectorLabel" => connectorLabel);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function unregister_connector(
connectorLabel,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/unregister-connector",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("connectorLabel" => connectorLabel), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag from the specified flow.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the flow that you want to untag.
- `tag_keys`: The tag keys associated with the tag that you want to remove from your flow.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_connector_profile(connection_mode, connector_profile_config, connector_profile_name)
update_connector_profile(connection_mode, connector_profile_config, connector_profile_name, params::Dict{String,<:Any})
Updates a given connector profile associated with your account.
# Arguments
- `connection_mode`: Indicates the connection mode and if it is public or private.
- `connector_profile_config`: Defines the connector-specific profile configuration and
credentials.
- `connector_profile_name`: The name of the connector profile and is unique for each
ConnectorProfile in the Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
UpdateConnectorProfile request completes only once. You choose the value to pass. For
example, if you don't receive a response from your request, you can safely retry the
request with the same clientToken parameter value. If you omit a clientToken value, the
Amazon Web Services SDK that you are using inserts a value for you. This way, the SDK can
safely retry requests multiple times after a network error. You must provide your own value
for other use cases. If you specify input parameters that differ from your first request,
an error occurs. If you use a different value for clientToken, Amazon AppFlow considers it
a new call to UpdateConnectorProfile. The token is active for 8 hours.
"""
function update_connector_profile(
connectionMode,
connectorProfileConfig,
connectorProfileName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/update-connector-profile",
Dict{String,Any}(
"connectionMode" => connectionMode,
"connectorProfileConfig" => connectorProfileConfig,
"connectorProfileName" => connectorProfileName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_connector_profile(
connectionMode,
connectorProfileConfig,
connectorProfileName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/update-connector-profile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"connectionMode" => connectionMode,
"connectorProfileConfig" => connectorProfileConfig,
"connectorProfileName" => connectorProfileName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_connector_registration(connector_label)
update_connector_registration(connector_label, params::Dict{String,<:Any})
Updates a custom connector that you've previously registered. This operation updates the
connector with one of the following: The latest version of the AWS Lambda function that's
assigned to the connector A new AWS Lambda function that you specify
# Arguments
- `connector_label`: The name of the connector. The name is unique for each connector
registration in your AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
UpdateConnectorRegistration request completes only once. You choose the value to pass. For
example, if you don't receive a response from your request, you can safely retry the
request with the same clientToken parameter value. If you omit a clientToken value, the
Amazon Web Services SDK that you are using inserts a value for you. This way, the SDK can
safely retry requests multiple times after a network error. You must provide your own value
for other use cases. If you specify input parameters that differ from your first request,
an error occurs. If you use a different value for clientToken, Amazon AppFlow considers it
a new call to UpdateConnectorRegistration. The token is active for 8 hours.
- `"connectorProvisioningConfig"`:
- `"description"`: A description about the update that you're applying to the connector.
"""
function update_connector_registration(
connectorLabel; aws_config::AbstractAWSConfig=global_aws_config()
)
return appflow(
"POST",
"/update-connector-registration",
Dict{String,Any}(
"connectorLabel" => connectorLabel, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_connector_registration(
connectorLabel,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/update-connector-registration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"connectorLabel" => connectorLabel, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_flow(destination_flow_config_list, flow_name, source_flow_config, tasks, trigger_config)
update_flow(destination_flow_config_list, flow_name, source_flow_config, tasks, trigger_config, params::Dict{String,<:Any})
Updates an existing flow.
# Arguments
- `destination_flow_config_list`: The configuration that controls how Amazon AppFlow
transfers data to the destination connector.
- `flow_name`: The specified name of the flow. Spaces are not allowed. Use underscores (_)
or hyphens (-) only.
- `source_flow_config`:
- `tasks`: A list of tasks that Amazon AppFlow performs while transferring the data in the
flow run.
- `trigger_config`: The trigger settings that determine how and when the flow runs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The clientToken parameter is an idempotency token. It ensures that your
UpdateFlow request completes only once. You choose the value to pass. For example, if you
don't receive a response from your request, you can safely retry the request with the same
clientToken parameter value. If you omit a clientToken value, the Amazon Web Services SDK
that you are using inserts a value for you. This way, the SDK can safely retry requests
multiple times after a network error. You must provide your own value for other use cases.
If you specify input parameters that differ from your first request, an error occurs. If
you use a different value for clientToken, Amazon AppFlow considers it a new call to
UpdateFlow. The token is active for 8 hours.
- `"description"`: A description of the flow.
- `"metadataCatalogConfig"`: Specifies the configuration that Amazon AppFlow uses when it
catalogs the data that's transferred by the associated flow. When Amazon AppFlow catalogs
the data from a flow, it stores metadata in a data catalog.
"""
function update_flow(
destinationFlowConfigList,
flowName,
sourceFlowConfig,
tasks,
triggerConfig;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/update-flow",
Dict{String,Any}(
"destinationFlowConfigList" => destinationFlowConfigList,
"flowName" => flowName,
"sourceFlowConfig" => sourceFlowConfig,
"tasks" => tasks,
"triggerConfig" => triggerConfig,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_flow(
destinationFlowConfigList,
flowName,
sourceFlowConfig,
tasks,
triggerConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appflow(
"POST",
"/update-flow",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationFlowConfigList" => destinationFlowConfigList,
"flowName" => flowName,
"sourceFlowConfig" => sourceFlowConfig,
"tasks" => tasks,
"triggerConfig" => triggerConfig,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 27089 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appintegrations
using AWS.Compat
using AWS.UUIDs
"""
create_application(application_source_config, name, namespace)
create_application(application_source_config, name, namespace, params::Dict{String,<:Any})
This API is in preview release and subject to change. Creates and persists an Application
resource.
# Arguments
- `application_source_config`: The configuration for where the application should be loaded
from.
- `name`: The name of the application.
- `namespace`: The namespace of the application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. If not provided, the Amazon Web Services SDK populates this
field. For more information about idempotency, see Making retries safe with idempotent APIs.
- `"Description"`: The description of the application.
- `"Permissions"`: The configuration of events or requests that the application has access
to.
- `"Publications"`: The events that the application publishes.
- `"Subscriptions"`: The events that the application subscribes.
- `"Tags"`: The tags used to organize, track, or control access for this resource. For
example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.
"""
function create_application(
ApplicationSourceConfig,
Name,
Namespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"POST",
"/applications",
Dict{String,Any}(
"ApplicationSourceConfig" => ApplicationSourceConfig,
"Name" => Name,
"Namespace" => Namespace,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_application(
ApplicationSourceConfig,
Name,
Namespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"POST",
"/applications",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationSourceConfig" => ApplicationSourceConfig,
"Name" => Name,
"Namespace" => Namespace,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_data_integration(kms_key, name, source_uri)
create_data_integration(kms_key, name, source_uri, params::Dict{String,<:Any})
Creates and persists a DataIntegration resource. You cannot create a DataIntegration
association for a DataIntegration that has been previously associated. Use a different
DataIntegration, or recreate the DataIntegration using the CreateDataIntegration API.
# Arguments
- `kms_key`: The KMS key for the DataIntegration.
- `name`: The name of the DataIntegration.
- `source_uri`: The URI of the data source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. If not provided, the Amazon Web Services SDK populates this
field. For more information about idempotency, see Making retries safe with idempotent APIs.
- `"Description"`: A description of the DataIntegration.
- `"FileConfiguration"`: The configuration for what files should be pulled from the source.
- `"ObjectConfiguration"`: The configuration for what data should be pulled from the source.
- `"ScheduleConfig"`: The name of the data and how often it should be pulled from the
source.
- `"Tags"`: The tags used to organize, track, or control access for this resource. For
example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.
"""
function create_data_integration(
KmsKey, Name, SourceURI; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"POST",
"/dataIntegrations",
Dict{String,Any}(
"KmsKey" => KmsKey,
"Name" => Name,
"SourceURI" => SourceURI,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_data_integration(
KmsKey,
Name,
SourceURI,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"POST",
"/dataIntegrations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"KmsKey" => KmsKey,
"Name" => Name,
"SourceURI" => SourceURI,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_event_integration(event_bridge_bus, event_filter, name)
create_event_integration(event_bridge_bus, event_filter, name, params::Dict{String,<:Any})
Creates an EventIntegration, given a specified name, description, and a reference to an
Amazon EventBridge bus in your account and a partner event source that pushes events to
that bus. No objects are created in the your account, only metadata that is persisted on
the EventIntegration control plane.
# Arguments
- `event_bridge_bus`: The EventBridge bus.
- `event_filter`: The event filter.
- `name`: The name of the event integration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique, case-sensitive identifier that you provide to ensure the
idempotency of the request. If not provided, the Amazon Web Services SDK populates this
field. For more information about idempotency, see Making retries safe with idempotent APIs.
- `"Description"`: The description of the event integration.
- `"Tags"`: The tags used to organize, track, or control access for this resource. For
example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.
"""
function create_event_integration(
EventBridgeBus, EventFilter, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"POST",
"/eventIntegrations",
Dict{String,Any}(
"EventBridgeBus" => EventBridgeBus,
"EventFilter" => EventFilter,
"Name" => Name,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_event_integration(
EventBridgeBus,
EventFilter,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"POST",
"/eventIntegrations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EventBridgeBus" => EventBridgeBus,
"EventFilter" => EventFilter,
"Name" => Name,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_application(application_identifier)
delete_application(application_identifier, params::Dict{String,<:Any})
Deletes the Application. Only Applications that don't have any Application Associations can
be deleted.
# Arguments
- `application_identifier`: The Amazon Resource Name (ARN) of the Application.
"""
function delete_application(
ApplicationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"DELETE",
"/applications/$(ApplicationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_application(
ApplicationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"DELETE",
"/applications/$(ApplicationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_data_integration(identifier)
delete_data_integration(identifier, params::Dict{String,<:Any})
Deletes the DataIntegration. Only DataIntegrations that don't have any
DataIntegrationAssociations can be deleted. Deleting a DataIntegration also deletes the
underlying Amazon AppFlow flow and service linked role. You cannot create a
DataIntegration association for a DataIntegration that has been previously associated. Use
a different DataIntegration, or recreate the DataIntegration using the
CreateDataIntegration API.
# Arguments
- `identifier`: A unique identifier for the DataIntegration.
"""
function delete_data_integration(
Identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"DELETE",
"/dataIntegrations/$(Identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_data_integration(
Identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"DELETE",
"/dataIntegrations/$(Identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_event_integration(name)
delete_event_integration(name, params::Dict{String,<:Any})
Deletes the specified existing event integration. If the event integration is associated
with clients, the request is rejected.
# Arguments
- `name`: The name of the event integration.
"""
function delete_event_integration(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"DELETE",
"/eventIntegrations/$(Name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_event_integration(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"DELETE",
"/eventIntegrations/$(Name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_application(application_identifier)
get_application(application_identifier, params::Dict{String,<:Any})
This API is in preview release and subject to change. Get an Application resource.
# Arguments
- `application_identifier`: The Amazon Resource Name (ARN) of the Application.
"""
function get_application(
ApplicationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/applications/$(ApplicationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_application(
ApplicationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"GET",
"/applications/$(ApplicationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_data_integration(identifier)
get_data_integration(identifier, params::Dict{String,<:Any})
Returns information about the DataIntegration. You cannot create a DataIntegration
association for a DataIntegration that has been previously associated. Use a different
DataIntegration, or recreate the DataIntegration using the CreateDataIntegration API.
# Arguments
- `identifier`: A unique identifier.
"""
function get_data_integration(Identifier; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"GET",
"/dataIntegrations/$(Identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_integration(
Identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"GET",
"/dataIntegrations/$(Identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_event_integration(name)
get_event_integration(name, params::Dict{String,<:Any})
Returns information about the event integration.
# Arguments
- `name`: The name of the event integration.
"""
function get_event_integration(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"GET",
"/eventIntegrations/$(Name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_event_integration(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/eventIntegrations/$(Name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_application_associations(application_identifier)
list_application_associations(application_identifier, params::Dict{String,<:Any})
Returns a paginated list of application associations for an application.
# Arguments
- `application_identifier`: A unique identifier for the Application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_application_associations(
ApplicationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/applications/$(ApplicationIdentifier)/associations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_application_associations(
ApplicationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"GET",
"/applications/$(ApplicationIdentifier)/associations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_applications()
list_applications(params::Dict{String,<:Any})
This API is in preview release and subject to change. Lists applications in the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"GET", "/applications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/applications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_data_integration_associations(identifier)
list_data_integration_associations(identifier, params::Dict{String,<:Any})
Returns a paginated list of DataIntegration associations in the account. You cannot create
a DataIntegration association for a DataIntegration that has been previously associated.
Use a different DataIntegration, or recreate the DataIntegration using the
CreateDataIntegration API.
# Arguments
- `identifier`: A unique identifier for the DataIntegration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_data_integration_associations(
Identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/dataIntegrations/$(Identifier)/associations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_data_integration_associations(
Identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"GET",
"/dataIntegrations/$(Identifier)/associations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_data_integrations()
list_data_integrations(params::Dict{String,<:Any})
Returns a paginated list of DataIntegrations in the account. You cannot create a
DataIntegration association for a DataIntegration that has been previously associated. Use
a different DataIntegration, or recreate the DataIntegration using the
CreateDataIntegration API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_data_integrations(; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"GET", "/dataIntegrations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_data_integrations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/dataIntegrations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_event_integration_associations(name)
list_event_integration_associations(name, params::Dict{String,<:Any})
Returns a paginated list of event integration associations in the account.
# Arguments
- `name`: The name of the event integration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_event_integration_associations(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/eventIntegrations/$(Name)/associations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_event_integration_associations(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/eventIntegrations/$(Name)/associations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_event_integrations()
list_event_integrations(params::Dict{String,<:Any})
Returns a paginated list of event integrations in the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_event_integrations(; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"GET", "/eventIntegrations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_event_integrations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/eventIntegrations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists the tags for the specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds the specified tags to the specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tags`: The tags used to organize, track, or control access for this resource. For
example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the specified tags from the specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tag_keys`: The tag keys.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application(application_identifier)
update_application(application_identifier, params::Dict{String,<:Any})
This API is in preview release and subject to change. Updates and persists an Application
resource.
# Arguments
- `application_identifier`: The Amazon Resource Name (ARN) of the Application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApplicationSourceConfig"`: The configuration for where the application should be loaded
from.
- `"Description"`: The description of the application.
- `"Name"`: The name of the application.
- `"Permissions"`: The configuration of events or requests that the application has access
to.
- `"Publications"`: The events that the application publishes.
- `"Subscriptions"`: The events that the application subscribes.
"""
function update_application(
ApplicationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"PATCH",
"/applications/$(ApplicationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_application(
ApplicationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"PATCH",
"/applications/$(ApplicationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_data_integration(identifier)
update_data_integration(identifier, params::Dict{String,<:Any})
Updates the description of a DataIntegration. You cannot create a DataIntegration
association for a DataIntegration that has been previously associated. Use a different
DataIntegration, or recreate the DataIntegration using the CreateDataIntegration API.
# Arguments
- `identifier`: A unique identifier for the DataIntegration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the DataIntegration.
- `"Name"`: The name of the DataIntegration.
"""
function update_data_integration(
Identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"PATCH",
"/dataIntegrations/$(Identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_data_integration(
Identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appintegrations(
"PATCH",
"/dataIntegrations/$(Identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_event_integration(name)
update_event_integration(name, params::Dict{String,<:Any})
Updates the description of an event integration.
# Arguments
- `name`: The name of the event integration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the event integration.
"""
function update_event_integration(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appintegrations(
"PATCH",
"/eventIntegrations/$(Name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_event_integration(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appintegrations(
"PATCH",
"/eventIntegrations/$(Name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 97934 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: application_auto_scaling
using AWS.Compat
using AWS.UUIDs
"""
delete_scaling_policy(policy_name, resource_id, scalable_dimension, service_namespace)
delete_scaling_policy(policy_name, resource_id, scalable_dimension, service_namespace, params::Dict{String,<:Any})
Deletes the specified scaling policy for an Application Auto Scaling scalable target.
Deleting a step scaling policy deletes the underlying alarm action, but does not delete the
CloudWatch alarm associated with the scaling policy, even if it no longer has an associated
action. For more information, see Delete a step scaling policy and Delete a target tracking
scaling policy in the Application Auto Scaling User Guide.
# Arguments
- `policy_name`: The name of the scaling policy.
- `resource_id`: The identifier of the resource associated with the scalable target. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. ecs:service:DesiredCount - The desired
task count of an ECS service. elasticmapreduce:instancegroup:InstanceCount - The
instance count of an EMR Instance Group. ec2:spot-fleet-request:TargetCapacity - The
target capacity of a Spot Fleet. appstream:fleet:DesiredCapacity - The desired capacity
of an AppStream 2.0 fleet. dynamodb:table:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB table. dynamodb:table:WriteCapacityUnits - The provisioned write
capacity for a DynamoDB table. dynamodb:index:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB global secondary index. dynamodb:index:WriteCapacityUnits - The
provisioned write capacity for a DynamoDB global secondary index.
rds:cluster:ReadReplicaCount - The count of Aurora Replicas in an Aurora DB cluster.
Available for Aurora MySQL-compatible edition and Aurora PostgreSQL-compatible edition.
sagemaker:variant:DesiredInstanceCount - The number of EC2 instances for a SageMaker model
endpoint variant. custom-resource:ResourceType:Property - The scalable dimension for a
custom resource provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
"""
function delete_scaling_policy(
PolicyName,
ResourceId,
ScalableDimension,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeleteScalingPolicy",
Dict{String,Any}(
"PolicyName" => PolicyName,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scaling_policy(
PolicyName,
ResourceId,
ScalableDimension,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeleteScalingPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PolicyName" => PolicyName,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_scheduled_action(resource_id, scalable_dimension, scheduled_action_name, service_namespace)
delete_scheduled_action(resource_id, scalable_dimension, scheduled_action_name, service_namespace, params::Dict{String,<:Any})
Deletes the specified scheduled action for an Application Auto Scaling scalable target. For
more information, see Delete a scheduled action in the Application Auto Scaling User Guide.
# Arguments
- `resource_id`: The identifier of the resource associated with the scheduled action. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. ecs:service:DesiredCount - The desired
task count of an ECS service. elasticmapreduce:instancegroup:InstanceCount - The
instance count of an EMR Instance Group. ec2:spot-fleet-request:TargetCapacity - The
target capacity of a Spot Fleet. appstream:fleet:DesiredCapacity - The desired capacity
of an AppStream 2.0 fleet. dynamodb:table:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB table. dynamodb:table:WriteCapacityUnits - The provisioned write
capacity for a DynamoDB table. dynamodb:index:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB global secondary index. dynamodb:index:WriteCapacityUnits - The
provisioned write capacity for a DynamoDB global secondary index.
rds:cluster:ReadReplicaCount - The count of Aurora Replicas in an Aurora DB cluster.
Available for Aurora MySQL-compatible edition and Aurora PostgreSQL-compatible edition.
sagemaker:variant:DesiredInstanceCount - The number of EC2 instances for a SageMaker model
endpoint variant. custom-resource:ResourceType:Property - The scalable dimension for a
custom resource provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `scheduled_action_name`: The name of the scheduled action.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
"""
function delete_scheduled_action(
ResourceId,
ScalableDimension,
ScheduledActionName,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeleteScheduledAction",
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScheduledActionName" => ScheduledActionName,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scheduled_action(
ResourceId,
ScalableDimension,
ScheduledActionName,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeleteScheduledAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScheduledActionName" => ScheduledActionName,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_scalable_target(resource_id, scalable_dimension, service_namespace)
deregister_scalable_target(resource_id, scalable_dimension, service_namespace, params::Dict{String,<:Any})
Deregisters an Application Auto Scaling scalable target when you have finished using it. To
see which resources have been registered, use DescribeScalableTargets. Deregistering a
scalable target deletes the scaling policies and the scheduled actions that are associated
with it.
# Arguments
- `resource_id`: The identifier of the resource associated with the scalable target. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension associated with the scalable target. This
string consists of the service namespace, resource type, and scaling property.
ecs:service:DesiredCount - The desired task count of an ECS service.
elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR Instance Group.
ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot Fleet.
appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
"""
function deregister_scalable_target(
ResourceId,
ScalableDimension,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeregisterScalableTarget",
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_scalable_target(
ResourceId,
ScalableDimension,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DeregisterScalableTarget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scalable_targets(service_namespace)
describe_scalable_targets(service_namespace, params::Dict{String,<:Any})
Gets information about the scalable targets in the specified namespace. You can filter the
results using ResourceIds and ScalableDimension.
# Arguments
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of scalable targets. This value can be between 1 and
50. The default value is 50. If this parameter is used, the operation returns up to
MaxResults results at a time, along with a NextToken value. To get the next set of results,
include the NextToken value in a subsequent call. If this parameter is not used, the
operation returns up to 50 results and a NextToken value, if applicable.
- `"NextToken"`: The token for the next set of results.
- `"ResourceIds"`: The identifier of the resource associated with the scalable target. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `"ScalableDimension"`: The scalable dimension associated with the scalable target. This
string consists of the service namespace, resource type, and scaling property. If you
specify a scalable dimension, you must also specify a resource ID.
ecs:service:DesiredCount - The desired task count of an ECS service.
elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR Instance Group.
ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot Fleet.
appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
"""
function describe_scalable_targets(
ServiceNamespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"DescribeScalableTargets",
Dict{String,Any}("ServiceNamespace" => ServiceNamespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scalable_targets(
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DescribeScalableTargets",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ServiceNamespace" => ServiceNamespace), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_activities(service_namespace)
describe_scaling_activities(service_namespace, params::Dict{String,<:Any})
Provides descriptive information about the scaling activities in the specified namespace
from the previous six weeks. You can filter the results using ResourceId and
ScalableDimension. For information about viewing scaling activities using the Amazon Web
Services CLI, see Scaling activities for Application Auto Scaling.
# Arguments
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IncludeNotScaledActivities"`: Specifies whether to include activities that aren't
scaled (not scaled activities) in the response. Not scaled activities are activities that
aren't completed or started for various reasons, such as preventing infinite scaling loops.
For help interpreting the not scaled reason details in the response, see Scaling activities
for Application Auto Scaling.
- `"MaxResults"`: The maximum number of scalable targets. This value can be between 1 and
50. The default value is 50. If this parameter is used, the operation returns up to
MaxResults results at a time, along with a NextToken value. To get the next set of results,
include the NextToken value in a subsequent call. If this parameter is not used, the
operation returns up to 50 results and a NextToken value, if applicable.
- `"NextToken"`: The token for the next set of results.
- `"ResourceId"`: The identifier of the resource associated with the scaling activity. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `"ScalableDimension"`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. If you specify a scalable dimension, you
must also specify a resource ID. ecs:service:DesiredCount - The desired task count of an
ECS service. elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR
Instance Group. ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot
Fleet. appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
"""
function describe_scaling_activities(
ServiceNamespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"DescribeScalingActivities",
Dict{String,Any}("ServiceNamespace" => ServiceNamespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scaling_activities(
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DescribeScalingActivities",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ServiceNamespace" => ServiceNamespace), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_policies(service_namespace)
describe_scaling_policies(service_namespace, params::Dict{String,<:Any})
Describes the Application Auto Scaling scaling policies for the specified service
namespace. You can filter the results using ResourceId, ScalableDimension, and PolicyNames.
For more information, see Target tracking scaling policies and Step scaling policies in the
Application Auto Scaling User Guide.
# Arguments
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of scalable targets. This value can be between 1 and
10. The default value is 10. If this parameter is used, the operation returns up to
MaxResults results at a time, along with a NextToken value. To get the next set of results,
include the NextToken value in a subsequent call. If this parameter is not used, the
operation returns up to 10 results and a NextToken value, if applicable.
- `"NextToken"`: The token for the next set of results.
- `"PolicyNames"`: The names of the scaling policies to describe.
- `"ResourceId"`: The identifier of the resource associated with the scaling policy. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `"ScalableDimension"`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. If you specify a scalable dimension, you
must also specify a resource ID. ecs:service:DesiredCount - The desired task count of an
ECS service. elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR
Instance Group. ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot
Fleet. appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
"""
function describe_scaling_policies(
ServiceNamespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"DescribeScalingPolicies",
Dict{String,Any}("ServiceNamespace" => ServiceNamespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scaling_policies(
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DescribeScalingPolicies",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ServiceNamespace" => ServiceNamespace), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scheduled_actions(service_namespace)
describe_scheduled_actions(service_namespace, params::Dict{String,<:Any})
Describes the Application Auto Scaling scheduled actions for the specified service
namespace. You can filter the results using the ResourceId, ScalableDimension, and
ScheduledActionNames parameters. For more information, see Scheduled scaling and Managing
scheduled scaling in the Application Auto Scaling User Guide.
# Arguments
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of scheduled action results. This value can be between
1 and 50. The default value is 50. If this parameter is used, the operation returns up to
MaxResults results at a time, along with a NextToken value. To get the next set of results,
include the NextToken value in a subsequent call. If this parameter is not used, the
operation returns up to 50 results and a NextToken value, if applicable.
- `"NextToken"`: The token for the next set of results.
- `"ResourceId"`: The identifier of the resource associated with the scheduled action. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `"ScalableDimension"`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. If you specify a scalable dimension, you
must also specify a resource ID. ecs:service:DesiredCount - The desired task count of an
ECS service. elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR
Instance Group. ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot
Fleet. appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `"ScheduledActionNames"`: The names of the scheduled actions to describe.
"""
function describe_scheduled_actions(
ServiceNamespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"DescribeScheduledActions",
Dict{String,Any}("ServiceNamespace" => ServiceNamespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scheduled_actions(
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"DescribeScheduledActions",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ServiceNamespace" => ServiceNamespace), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns all the tags on the specified Application Auto Scaling scalable target. For general
information about tags, including the format and syntax, see Tagging Amazon Web Services
resources in the Amazon Web Services General Reference.
# Arguments
- `resource_arn`: Specify the ARN of the scalable target. For example:
arn:aws:application-autoscaling:us-east-1:123456789012:scalable-target/1234abcd56ab78cd901ef
1234567890ab123 To get the ARN for a scalable target, use DescribeScalableTargets.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_scaling_policy(policy_name, resource_id, scalable_dimension, service_namespace)
put_scaling_policy(policy_name, resource_id, scalable_dimension, service_namespace, params::Dict{String,<:Any})
Creates or updates a scaling policy for an Application Auto Scaling scalable target. Each
scalable target is identified by a service namespace, resource ID, and scalable dimension.
A scaling policy applies to the scalable target identified by those three attributes. You
cannot create a scaling policy until you have registered the resource as a scalable target.
Multiple scaling policies can be in force at the same time for the same scalable target.
You can have one or more target tracking scaling policies, one or more step scaling
policies, or both. However, there is a chance that multiple policies could conflict,
instructing the scalable target to scale out or in at the same time. Application Auto
Scaling gives precedence to the policy that provides the largest capacity for both scale
out and scale in. For example, if one policy increases capacity by 3, another policy
increases capacity by 200 percent, and the current capacity is 10, Application Auto Scaling
uses the policy with the highest calculated capacity (200% of 10 = 20) and scales out to
30. We recommend caution, however, when using target tracking scaling policies with step
scaling policies because conflicts between these policies can cause undesirable behavior.
For example, if the step scaling policy initiates a scale-in activity before the target
tracking policy is ready to scale in, the scale-in activity will not be blocked. After the
scale-in activity completes, the target tracking policy could instruct the scalable target
to scale out again. For more information, see Target tracking scaling policies and Step
scaling policies in the Application Auto Scaling User Guide. If a scalable target is
deregistered, the scalable target is no longer available to use scaling policies. Any
scaling policies that were specified for the scalable target are deleted.
# Arguments
- `policy_name`: The name of the scaling policy. You cannot change the name of a scaling
policy, but you can delete the original scaling policy and create a new scaling policy with
the same settings and a different name.
- `resource_id`: The identifier of the resource associated with the scaling policy. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. ecs:service:DesiredCount - The desired
task count of an ECS service. elasticmapreduce:instancegroup:InstanceCount - The
instance count of an EMR Instance Group. ec2:spot-fleet-request:TargetCapacity - The
target capacity of a Spot Fleet. appstream:fleet:DesiredCapacity - The desired capacity
of an AppStream 2.0 fleet. dynamodb:table:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB table. dynamodb:table:WriteCapacityUnits - The provisioned write
capacity for a DynamoDB table. dynamodb:index:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB global secondary index. dynamodb:index:WriteCapacityUnits - The
provisioned write capacity for a DynamoDB global secondary index.
rds:cluster:ReadReplicaCount - The count of Aurora Replicas in an Aurora DB cluster.
Available for Aurora MySQL-compatible edition and Aurora PostgreSQL-compatible edition.
sagemaker:variant:DesiredInstanceCount - The number of EC2 instances for a SageMaker model
endpoint variant. custom-resource:ResourceType:Property - The scalable dimension for a
custom resource provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PolicyType"`: The scaling policy type. This parameter is required if you are creating a
scaling policy. The following policy types are supported: TargetTrackingScaling—Not
supported for Amazon EMR. StepScaling—Not supported for DynamoDB, Amazon Comprehend,
Lambda, Amazon Keyspaces, Amazon MSK, Amazon ElastiCache, or Neptune. For more information,
see Target tracking scaling policies and Step scaling policies in the Application Auto
Scaling User Guide.
- `"StepScalingPolicyConfiguration"`: A step scaling policy. This parameter is required if
you are creating a policy and the policy type is StepScaling.
- `"TargetTrackingScalingPolicyConfiguration"`: A target tracking scaling policy. Includes
support for predefined or customized metrics. This parameter is required if you are
creating a policy and the policy type is TargetTrackingScaling.
"""
function put_scaling_policy(
PolicyName,
ResourceId,
ScalableDimension,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"PutScalingPolicy",
Dict{String,Any}(
"PolicyName" => PolicyName,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_scaling_policy(
PolicyName,
ResourceId,
ScalableDimension,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"PutScalingPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PolicyName" => PolicyName,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_scheduled_action(resource_id, scalable_dimension, scheduled_action_name, service_namespace)
put_scheduled_action(resource_id, scalable_dimension, scheduled_action_name, service_namespace, params::Dict{String,<:Any})
Creates or updates a scheduled action for an Application Auto Scaling scalable target.
Each scalable target is identified by a service namespace, resource ID, and scalable
dimension. A scheduled action applies to the scalable target identified by those three
attributes. You cannot create a scheduled action until you have registered the resource as
a scalable target. When you specify start and end times with a recurring schedule using a
cron expression or rates, they form the boundaries for when the recurring action starts and
stops. To update a scheduled action, specify the parameters that you want to change. If you
don't specify start and end times, the old values are deleted. For more information, see
Scheduled scaling in the Application Auto Scaling User Guide. If a scalable target is
deregistered, the scalable target is no longer available to run scheduled actions. Any
scheduled actions that were specified for the scalable target are deleted.
# Arguments
- `resource_id`: The identifier of the resource associated with the scheduled action. This
string consists of the resource type and unique identifier. ECS service - The resource
type is service and the unique identifier is the cluster name and service name. Example:
service/default/sample-webapp. Spot Fleet - The resource type is spot-fleet-request and
the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension. This string consists of the service
namespace, resource type, and scaling property. ecs:service:DesiredCount - The desired
task count of an ECS service. elasticmapreduce:instancegroup:InstanceCount - The
instance count of an EMR Instance Group. ec2:spot-fleet-request:TargetCapacity - The
target capacity of a Spot Fleet. appstream:fleet:DesiredCapacity - The desired capacity
of an AppStream 2.0 fleet. dynamodb:table:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB table. dynamodb:table:WriteCapacityUnits - The provisioned write
capacity for a DynamoDB table. dynamodb:index:ReadCapacityUnits - The provisioned read
capacity for a DynamoDB global secondary index. dynamodb:index:WriteCapacityUnits - The
provisioned write capacity for a DynamoDB global secondary index.
rds:cluster:ReadReplicaCount - The count of Aurora Replicas in an Aurora DB cluster.
Available for Aurora MySQL-compatible edition and Aurora PostgreSQL-compatible edition.
sagemaker:variant:DesiredInstanceCount - The number of EC2 instances for a SageMaker model
endpoint variant. custom-resource:ResourceType:Property - The scalable dimension for a
custom resource provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `scheduled_action_name`: The name of the scheduled action. This name must be unique among
all other scheduled actions on the specified scalable target.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EndTime"`: The date and time for the recurring schedule to end, in UTC.
- `"ScalableTargetAction"`: The new minimum and maximum capacity. You can set both values
or just one. At the scheduled time, if the current capacity is below the minimum capacity,
Application Auto Scaling scales out to the minimum capacity. If the current capacity is
above the maximum capacity, Application Auto Scaling scales in to the maximum capacity.
- `"Schedule"`: The schedule for this action. The following formats are supported: At
expressions - \"at(yyyy-mm-ddThh:mm:ss)\" Rate expressions - \"rate(value unit)\" Cron
expressions - \"cron(fields)\" At expressions are useful for one-time schedules. Cron
expressions are useful for scheduled actions that run periodically at a specified date and
time, and rate expressions are useful for scheduled actions that run at a regular interval.
At and cron expressions use Universal Coordinated Time (UTC) by default. The cron format
consists of six fields separated by white spaces: [Minutes] [Hours] [Day_of_Month] [Month]
[Day_of_Week] [Year]. For rate expressions, value is a positive integer and unit is minute
| minutes | hour | hours | day | days. For more information and examples, see Example
scheduled actions for Application Auto Scaling in the Application Auto Scaling User Guide.
- `"StartTime"`: The date and time for this scheduled action to start, in UTC.
- `"Timezone"`: Specifies the time zone used when setting a scheduled action by using an at
or cron expression. If a time zone is not provided, UTC is used by default. Valid values
are the canonical names of the IANA time zones supported by Joda-Time (such as Etc/GMT+9 or
Pacific/Tahiti). For more information, see https://www.joda.org/joda-time/timezones.html.
"""
function put_scheduled_action(
ResourceId,
ScalableDimension,
ScheduledActionName,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"PutScheduledAction",
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScheduledActionName" => ScheduledActionName,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_scheduled_action(
ResourceId,
ScalableDimension,
ScheduledActionName,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"PutScheduledAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScheduledActionName" => ScheduledActionName,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_scalable_target(resource_id, scalable_dimension, service_namespace)
register_scalable_target(resource_id, scalable_dimension, service_namespace, params::Dict{String,<:Any})
Registers or updates a scalable target, which is the resource that you want to scale.
Scalable targets are uniquely identified by the combination of resource ID, scalable
dimension, and namespace, which represents some capacity dimension of the underlying
service. When you register a new scalable target, you must specify values for the minimum
and maximum capacity. If the specified resource is not active in the target service, this
operation does not change the resource's current capacity. Otherwise, it changes the
resource's current capacity to a value that is inside of this range. If you add a scaling
policy, current capacity is adjustable within the specified range when scaling starts.
Application Auto Scaling scaling policies will not scale capacity to values that are
outside of the minimum and maximum range. After you register a scalable target, you do not
need to register it again to use other Application Auto Scaling operations. To see which
resources have been registered, use DescribeScalableTargets. You can also view the scaling
policies for a service namespace by using DescribeScalableTargets. If you no longer need a
scalable target, you can deregister it by using DeregisterScalableTarget. To update a
scalable target, specify the parameters that you want to change. Include the parameters
that identify the scalable target: resource ID, scalable dimension, and namespace. Any
parameters that you don't specify are not changed by this update request. If you call the
RegisterScalableTarget API operation to create a scalable target, there might be a brief
delay until the operation achieves eventual consistency. You might become aware of this
brief delay if you get unexpected errors when performing sequential operations. The typical
strategy is to retry the request, and some Amazon Web Services SDKs include automatic
backoff and retry logic. If you call the RegisterScalableTarget API operation to update an
existing scalable target, Application Auto Scaling retrieves the current capacity of the
resource. If it's below the minimum capacity or above the maximum capacity, Application
Auto Scaling adjusts the capacity of the scalable target to place it within these bounds,
even if you don't include the MinCapacity or MaxCapacity request parameters.
# Arguments
- `resource_id`: The identifier of the resource that is associated with the scalable
target. This string consists of the resource type and unique identifier. ECS service -
The resource type is service and the unique identifier is the cluster name and service
name. Example: service/default/sample-webapp. Spot Fleet - The resource type is
spot-fleet-request and the unique identifier is the Spot Fleet request ID. Example:
spot-fleet-request/sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE. EMR cluster - The resource
type is instancegroup and the unique identifier is the cluster ID and instance group ID.
Example: instancegroup/j-2EEZNYKUA1NTV/ig-1791Y4E1L8YI0. AppStream 2.0 fleet - The
resource type is fleet and the unique identifier is the fleet name. Example:
fleet/sample-fleet. DynamoDB table - The resource type is table and the unique identifier
is the table name. Example: table/my-table. DynamoDB global secondary index - The
resource type is index and the unique identifier is the index name. Example:
table/my-table/index/my-table-index. Aurora DB cluster - The resource type is cluster and
the unique identifier is the cluster name. Example: cluster:my-db-cluster. SageMaker
endpoint variant - The resource type is variant and the unique identifier is the resource
ID. Example: endpoint/my-end-point/variant/KMeansClustering. Custom resources are not
supported with a resource type. This parameter must specify the OutputValue from the
CloudFormation template stack used to access the resources. The unique identifier is
defined by the service provider. More information is available in our GitHub repository.
Amazon Comprehend document classification endpoint - The resource type and unique
identifier are specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:document-classifier-endpoint/EXAMPLE. Amazon
Comprehend entity recognizer endpoint - The resource type and unique identifier are
specified using the endpoint ARN. Example:
arn:aws:comprehend:us-west-2:123456789012:entity-recognizer-endpoint/EXAMPLE. Lambda
provisioned concurrency - The resource type is function and the unique identifier is the
function name with a function version or alias name suffix that is not LATEST. Example:
function:my-function:prod or function:my-function:1. Amazon Keyspaces table - The
resource type is table and the unique identifier is the table name. Example:
keyspace/mykeyspace/table/mytable. Amazon MSK cluster - The resource type and unique
identifier are specified using the cluster ARN. Example:
arn:aws:kafka:us-east-1:123456789012:cluster/demo-cluster-1/6357e0b2-0e6a-4b86-a0b4-70df934c
2e31-5. Amazon ElastiCache replication group - The resource type is replication-group and
the unique identifier is the replication group name. Example: replication-group/mycluster.
Neptune cluster - The resource type is cluster and the unique identifier is the cluster
name. Example: cluster:mycluster. SageMaker Serverless endpoint - The resource type is
variant and the unique identifier is the resource ID. Example:
endpoint/my-end-point/variant/KMeansClustering. SageMaker inference component - The
resource type is inference-component and the unique identifier is the resource ID. Example:
inference-component/my-inference-component.
- `scalable_dimension`: The scalable dimension associated with the scalable target. This
string consists of the service namespace, resource type, and scaling property.
ecs:service:DesiredCount - The desired task count of an ECS service.
elasticmapreduce:instancegroup:InstanceCount - The instance count of an EMR Instance Group.
ec2:spot-fleet-request:TargetCapacity - The target capacity of a Spot Fleet.
appstream:fleet:DesiredCapacity - The desired capacity of an AppStream 2.0 fleet.
dynamodb:table:ReadCapacityUnits - The provisioned read capacity for a DynamoDB table.
dynamodb:table:WriteCapacityUnits - The provisioned write capacity for a DynamoDB table.
dynamodb:index:ReadCapacityUnits - The provisioned read capacity for a DynamoDB global
secondary index. dynamodb:index:WriteCapacityUnits - The provisioned write capacity for
a DynamoDB global secondary index. rds:cluster:ReadReplicaCount - The count of Aurora
Replicas in an Aurora DB cluster. Available for Aurora MySQL-compatible edition and Aurora
PostgreSQL-compatible edition. sagemaker:variant:DesiredInstanceCount - The number of
EC2 instances for a SageMaker model endpoint variant.
custom-resource:ResourceType:Property - The scalable dimension for a custom resource
provided by your own application or service.
comprehend:document-classifier-endpoint:DesiredInferenceUnits - The number of inference
units for an Amazon Comprehend document classification endpoint.
comprehend:entity-recognizer-endpoint:DesiredInferenceUnits - The number of inference units
for an Amazon Comprehend entity recognizer endpoint.
lambda:function:ProvisionedConcurrency - The provisioned concurrency for a Lambda function.
cassandra:table:ReadCapacityUnits - The provisioned read capacity for an Amazon
Keyspaces table. cassandra:table:WriteCapacityUnits - The provisioned write capacity for
an Amazon Keyspaces table. kafka:broker-storage:VolumeSize - The provisioned volume size
(in GiB) for brokers in an Amazon MSK cluster. elasticache:replication-group:NodeGroups
- The number of node groups for an Amazon ElastiCache replication group.
elasticache:replication-group:Replicas - The number of replicas per node group for an
Amazon ElastiCache replication group. neptune:cluster:ReadReplicaCount - The count of
read replicas in an Amazon Neptune DB cluster.
sagemaker:variant:DesiredProvisionedConcurrency - The provisioned concurrency for a
SageMaker Serverless endpoint. sagemaker:inference-component:DesiredCopyCount - The
number of copies across an endpoint for a SageMaker inference component.
- `service_namespace`: The namespace of the Amazon Web Services service that provides the
resource. For a resource provided by your own application or service, use custom-resource
instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxCapacity"`: The maximum value that you plan to scale out to. When a scaling policy
is in effect, Application Auto Scaling can scale out (expand) as needed to the maximum
capacity limit in response to changing demand. This property is required when registering a
new scalable target. Although you can specify a large maximum capacity, note that service
quotas might impose lower limits. Each service has its own default quotas for the maximum
capacity of the resource. If you want to specify a higher limit, you can request an
increase. For more information, consult the documentation for that service. For information
about the default quotas for each service, see Service endpoints and quotas in the Amazon
Web Services General Reference.
- `"MinCapacity"`: The minimum value that you plan to scale in to. When a scaling policy is
in effect, Application Auto Scaling can scale in (contract) as needed to the minimum
capacity limit in response to changing demand. This property is required when registering a
new scalable target. For the following resources, the minimum value allowed is 0.
AppStream 2.0 fleets Aurora DB clusters ECS services EMR clusters Lambda
provisioned concurrency SageMaker endpoint variants SageMaker Serverless endpoint
provisioned concurrency Spot Fleets custom resources It's strongly recommended that
you specify a value greater than 0. A value greater than 0 means that data points are
continuously reported to CloudWatch that scaling policies can use to scale on a metric like
average CPU utilization. For all other resources, the minimum allowed value depends on the
type of resource that you are using. If you provide a value that is lower than what a
resource can accept, an error occurs. In which case, the error message will provide the
minimum value that the resource can accept.
- `"RoleARN"`: This parameter is required for services that do not support service-linked
roles (such as Amazon EMR), and it must specify the ARN of an IAM role that allows
Application Auto Scaling to modify the scalable target on your behalf. If the service
supports service-linked roles, Application Auto Scaling uses a service-linked role, which
it creates if it does not yet exist. For more information, see Application Auto Scaling IAM
roles.
- `"SuspendedState"`: An embedded object that contains attributes and attribute values that
are used to suspend and resume automatic scaling. Setting the value of an attribute to true
suspends the specified scaling activities. Setting it to false (default) resumes the
specified scaling activities. Suspension Outcomes For DynamicScalingInSuspended, while
a suspension is in effect, all scale-in activities that are triggered by a scaling policy
are suspended. For DynamicScalingOutSuspended, while a suspension is in effect, all
scale-out activities that are triggered by a scaling policy are suspended. For
ScheduledScalingSuspended, while a suspension is in effect, all scaling activities that
involve scheduled actions are suspended. For more information, see Suspending and
resuming scaling in the Application Auto Scaling User Guide.
- `"Tags"`: Assigns one or more tags to the scalable target. Use this parameter to tag the
scalable target when it is created. To tag an existing scalable target, use the TagResource
operation. Each tag consists of a tag key and a tag value. Both the tag key and the tag
value are required. You cannot have more than one tag on a scalable target with the same
tag key. Use tags to control access to a scalable target. For more information, see Tagging
support for Application Auto Scaling in the Application Auto Scaling User Guide.
"""
function register_scalable_target(
ResourceId,
ScalableDimension,
ServiceNamespace;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"RegisterScalableTarget",
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_scalable_target(
ResourceId,
ScalableDimension,
ServiceNamespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"RegisterScalableTarget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ServiceNamespace" => ServiceNamespace,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds or edits tags on an Application Auto Scaling scalable target. Each tag consists of a
tag key and a tag value, which are both case-sensitive strings. To add a tag, specify a new
tag key and a tag value. To edit a tag, specify an existing tag key and a new tag value.
You can use this operation to tag an Application Auto Scaling scalable target, but you
cannot tag a scaling policy or scheduled action. You can also add tags to an Application
Auto Scaling scalable target while creating it (RegisterScalableTarget). For general
information about tags, including the format and syntax, see Tagging Amazon Web Services
resources in the Amazon Web Services General Reference. Use tags to control access to a
scalable target. For more information, see Tagging support for Application Auto Scaling in
the Application Auto Scaling User Guide.
# Arguments
- `resource_arn`: Identifies the Application Auto Scaling scalable target that you want to
apply tags to. For example:
arn:aws:application-autoscaling:us-east-1:123456789012:scalable-target/1234abcd56ab78cd901ef
1234567890ab123 To get the ARN for a scalable target, use DescribeScalableTargets.
- `tags`: The tags assigned to the resource. A tag is a label that you assign to an Amazon
Web Services resource. Each tag consists of a tag key and a tag value. You cannot have more
than one tag on an Application Auto Scaling scalable target with the same tag key. If you
specify an existing tag key with a different tag value, Application Auto Scaling replaces
the current tag value with the specified one. For information about the rules that apply to
tag keys and tag values, see User-defined tag restrictions in the Amazon Web Services
Billing and Cost Management User Guide.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return application_auto_scaling(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Deletes tags from an Application Auto Scaling scalable target. To delete a tag, specify the
tag key and the Application Auto Scaling scalable target.
# Arguments
- `resource_arn`: Identifies the Application Auto Scaling scalable target from which to
remove tags. For example:
arn:aws:application-autoscaling:us-east-1:123456789012:scalable-target/1234abcd56ab78cd901ef
1234567890ab123 To get the ARN for a scalable target, use DescribeScalableTargets.
- `tag_keys`: One or more tag keys. Specify only the tag keys, not the tag values.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_auto_scaling(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_auto_scaling(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 42264 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: application_discovery_service
using AWS.Compat
using AWS.UUIDs
"""
associate_configuration_items_to_application(application_configuration_id, configuration_ids)
associate_configuration_items_to_application(application_configuration_id, configuration_ids, params::Dict{String,<:Any})
Associates one or more configuration items with an application.
# Arguments
- `application_configuration_id`: The configuration ID of an application with which items
are to be associated.
- `configuration_ids`: The ID of each configuration item to be associated with an
application.
"""
function associate_configuration_items_to_application(
applicationConfigurationId,
configurationIds;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"AssociateConfigurationItemsToApplication",
Dict{String,Any}(
"applicationConfigurationId" => applicationConfigurationId,
"configurationIds" => configurationIds,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_configuration_items_to_application(
applicationConfigurationId,
configurationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"AssociateConfigurationItemsToApplication",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationConfigurationId" => applicationConfigurationId,
"configurationIds" => configurationIds,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_agents(delete_agents)
batch_delete_agents(delete_agents, params::Dict{String,<:Any})
Deletes one or more agents or collectors as specified by ID. Deleting an agent or
collector does not delete the previously discovered data. To delete the data collected, use
StartBatchDeleteConfigurationTask.
# Arguments
- `delete_agents`: The list of agents to delete.
"""
function batch_delete_agents(
deleteAgents; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"BatchDeleteAgents",
Dict{String,Any}("deleteAgents" => deleteAgents);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_agents(
deleteAgents,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"BatchDeleteAgents",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deleteAgents" => deleteAgents), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_import_data(import_task_ids)
batch_delete_import_data(import_task_ids, params::Dict{String,<:Any})
Deletes one or more import tasks, each identified by their import ID. Each import task has
a number of records that can identify servers or applications. Amazon Web Services
Application Discovery Service has built-in matching logic that will identify when
discovered servers match existing entries that you've previously discovered, the
information for the already-existing discovered server is updated. When you delete an
import task that contains records that were used to match, the information in those matched
records that comes from the deleted records will also be deleted.
# Arguments
- `import_task_ids`: The IDs for the import tasks that you want to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deleteHistory"`: Set to true to remove the deleted import task from
DescribeImportTasks.
"""
function batch_delete_import_data(
importTaskIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"BatchDeleteImportData",
Dict{String,Any}("importTaskIds" => importTaskIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_import_data(
importTaskIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"BatchDeleteImportData",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("importTaskIds" => importTaskIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_application(name)
create_application(name, params::Dict{String,<:Any})
Creates an application with the given name and description.
# Arguments
- `name`: Name of the application to be created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: Description of the application to be created.
"""
function create_application(name; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"CreateApplication",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_application(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"CreateApplication",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_tags(configuration_ids, tags)
create_tags(configuration_ids, tags, params::Dict{String,<:Any})
Creates one or more tags for configuration items. Tags are metadata that help you
categorize IT assets. This API accepts a list of multiple configuration items. Do not
store sensitive information (like personal data) in tags.
# Arguments
- `configuration_ids`: A list of configuration items that you want to tag.
- `tags`: Tags that you want to associate with one or more configuration items. Specify the
tags that you want to create in a key-value format. For example: {\"key\": \"serverType\",
\"value\": \"webServer\"}
"""
function create_tags(
configurationIds, tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"CreateTags",
Dict{String,Any}("configurationIds" => configurationIds, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_tags(
configurationIds,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"CreateTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("configurationIds" => configurationIds, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_applications(configuration_ids)
delete_applications(configuration_ids, params::Dict{String,<:Any})
Deletes a list of applications and their associations with configuration items.
# Arguments
- `configuration_ids`: Configuration ID of an application to be deleted.
"""
function delete_applications(
configurationIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DeleteApplications",
Dict{String,Any}("configurationIds" => configurationIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_applications(
configurationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"DeleteApplications",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationIds" => configurationIds), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_tags(configuration_ids)
delete_tags(configuration_ids, params::Dict{String,<:Any})
Deletes the association between configuration items and one or more tags. This API accepts
a list of multiple configuration items.
# Arguments
- `configuration_ids`: A list of configuration items with tags that you want to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: Tags that you want to delete from one or more configuration items. Specify the
tags that you want to delete in a key-value format. For example: {\"key\": \"serverType\",
\"value\": \"webServer\"}
"""
function delete_tags(configurationIds; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DeleteTags",
Dict{String,Any}("configurationIds" => configurationIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_tags(
configurationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"DeleteTags",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationIds" => configurationIds), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_agents()
describe_agents(params::Dict{String,<:Any})
Lists agents or collectors as specified by ID or other filters. All agents/collectors
associated with your user can be listed if you call DescribeAgents as is without passing
any parameters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"agentIds"`: The agent or the collector IDs for which you want information. If you
specify no IDs, the system returns information about all agents/collectors associated with
your user.
- `"filters"`: You can filter the request using various logical operators and a key-value
format. For example: {\"key\": \"collectionStatus\", \"value\": \"STARTED\"}
- `"maxResults"`: The total number of agents/collectors to return in a single page of
output. The maximum value is 100.
- `"nextToken"`: Token to retrieve the next set of results. For example, if you previously
specified 100 IDs for DescribeAgentsRequestagentIds but set DescribeAgentsRequestmaxResults
to 10, you received a set of 10 results along with a token. Use that token in this query to
get the next set of 10.
"""
function describe_agents(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeAgents"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_agents(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeAgents", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_batch_delete_configuration_task(task_id)
describe_batch_delete_configuration_task(task_id, params::Dict{String,<:Any})
Takes a unique deletion task identifier as input and returns metadata about a
configuration deletion task.
# Arguments
- `task_id`: The ID of the task to delete.
"""
function describe_batch_delete_configuration_task(
taskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeBatchDeleteConfigurationTask",
Dict{String,Any}("taskId" => taskId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_batch_delete_configuration_task(
taskId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeBatchDeleteConfigurationTask",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("taskId" => taskId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_configurations(configuration_ids)
describe_configurations(configuration_ids, params::Dict{String,<:Any})
Retrieves attributes for a list of configuration item IDs. All of the supplied IDs must be
for the same asset type from one of the following: server application process
connection Output fields are specific to the asset type specified. For example, the
output for a server configuration item includes a list of attributes about the server, such
as host name, operating system, number of network cards, etc. For a complete list of
outputs for each asset type, see Using the DescribeConfigurations Action in the Amazon Web
Services Application Discovery Service User Guide.
# Arguments
- `configuration_ids`: One or more configuration IDs.
"""
function describe_configurations(
configurationIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeConfigurations",
Dict{String,Any}("configurationIds" => configurationIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_configurations(
configurationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"DescribeConfigurations",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationIds" => configurationIds), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_continuous_exports()
describe_continuous_exports(params::Dict{String,<:Any})
Lists exports as specified by ID. All continuous exports associated with your user can be
listed if you call DescribeContinuousExports as is without passing any parameters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"exportIds"`: The unique IDs assigned to the exports.
- `"maxResults"`: A number between 1 and 100 specifying the maximum number of continuous
export descriptions returned.
- `"nextToken"`: The token from the previous call to DescribeExportTasks.
"""
function describe_continuous_exports(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeContinuousExports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_continuous_exports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeContinuousExports",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_export_configurations()
describe_export_configurations(params::Dict{String,<:Any})
DescribeExportConfigurations is deprecated. Use DescribeExportTasks, instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"exportIds"`: A list of continuous export IDs to search for.
- `"maxResults"`: A number between 1 and 100 specifying the maximum number of continuous
export descriptions returned.
- `"nextToken"`: The token from the previous call to describe-export-tasks.
"""
function describe_export_configurations(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeExportConfigurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_export_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeExportConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_export_tasks()
describe_export_tasks(params::Dict{String,<:Any})
Retrieve status of one or more export tasks. You can retrieve the status of up to 100
export tasks.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"exportIds"`: One or more unique identifiers used to query the status of an export
request.
- `"filters"`: One or more filters. AgentId - ID of the agent whose collected data will
be exported
- `"maxResults"`: The maximum number of volume results returned by DescribeExportTasks in
paginated output. When this parameter is used, DescribeExportTasks only returns maxResults
results in a single page along with a nextToken response element.
- `"nextToken"`: The nextToken value returned from a previous paginated DescribeExportTasks
request where maxResults was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken
value. This value is null when there are no more results to return.
"""
function describe_export_tasks(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeExportTasks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_export_tasks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeExportTasks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_import_tasks()
describe_import_tasks(params::Dict{String,<:Any})
Returns an array of import tasks for your account, including status information, times,
IDs, the Amazon S3 Object URL for the import file, and more.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: An array of name-value pairs that you provide to filter the results for the
DescribeImportTask request to a specific subset of results. Currently, wildcard values
aren't supported for filters.
- `"maxResults"`: The maximum number of results that you want this request to return, up to
100.
- `"nextToken"`: The token to request a specific page of results.
"""
function describe_import_tasks(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeImportTasks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_import_tasks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeImportTasks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_tags()
describe_tags(params::Dict{String,<:Any})
Retrieves a list of configuration items that have tags as specified by the key-value pairs,
name and value, passed to the optional parameter filters. There are three valid tag filter
names: tagKey tagValue configurationId Also, all configuration items associated
with your user that have tags can be listed if you call DescribeTags as is without passing
any parameters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: You can filter the list using a key-value format. You can separate these
items by using logical operators. Allowed filters include tagKey, tagValue, and
configurationId.
- `"maxResults"`: The total number of items to return in a single page of output. The
maximum value is 100.
- `"nextToken"`: A token to start the list. Use this token to get the next set of results.
"""
function describe_tags(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"DescribeTags"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_tags(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"DescribeTags", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
disassociate_configuration_items_from_application(application_configuration_id, configuration_ids)
disassociate_configuration_items_from_application(application_configuration_id, configuration_ids, params::Dict{String,<:Any})
Disassociates one or more configuration items from an application.
# Arguments
- `application_configuration_id`: Configuration ID of an application from which each item
is disassociated.
- `configuration_ids`: Configuration ID of each item to be disassociated from an
application.
"""
function disassociate_configuration_items_from_application(
applicationConfigurationId,
configurationIds;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"DisassociateConfigurationItemsFromApplication",
Dict{String,Any}(
"applicationConfigurationId" => applicationConfigurationId,
"configurationIds" => configurationIds,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_configuration_items_from_application(
applicationConfigurationId,
configurationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"DisassociateConfigurationItemsFromApplication",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationConfigurationId" => applicationConfigurationId,
"configurationIds" => configurationIds,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_configurations()
export_configurations(params::Dict{String,<:Any})
Deprecated. Use StartExportTask instead. Exports all discovered configuration data to an
Amazon S3 bucket or an application that enables you to view and evaluate the data. Data
includes tags and tag associations, processes, connections, servers, and system
performance. This API returns an export ID that you can query using the
DescribeExportConfigurations API. The system imposes a limit of two configuration exports
in six hours.
"""
function export_configurations(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"ExportConfigurations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function export_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"ExportConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_discovery_summary()
get_discovery_summary(params::Dict{String,<:Any})
Retrieves a short summary of discovered assets. This API operation takes no request
parameters and is called as is at the command prompt as shown in the example.
"""
function get_discovery_summary(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"GetDiscoverySummary"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_discovery_summary(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"GetDiscoverySummary",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configurations(configuration_type)
list_configurations(configuration_type, params::Dict{String,<:Any})
Retrieves a list of configuration items as specified by the value passed to the required
parameter configurationType. Optional filtering may be applied to refine search results.
# Arguments
- `configuration_type`: A valid configuration identified by Application Discovery Service.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: You can filter the request using various logical operators and a key-value
format. For example: {\"key\": \"serverType\", \"value\": \"webServer\"} For a complete
list of filter options and guidance about using them with this action, see Using the
ListConfigurations Action in the Amazon Web Services Application Discovery Service User
Guide.
- `"maxResults"`: The total number of items to return. The maximum value is 100.
- `"nextToken"`: Token to retrieve the next set of results. For example, if a previous call
to ListConfigurations returned 100 items, but you set ListConfigurationsRequestmaxResults
to 10, you received a set of 10 results along with a token. Use that token in this query to
get the next set of 10.
- `"orderBy"`: Certain filter criteria return output that can be sorted in ascending or
descending order. For a list of output characteristics for each filter, see Using the
ListConfigurations Action in the Amazon Web Services Application Discovery Service User
Guide.
"""
function list_configurations(
configurationType; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"ListConfigurations",
Dict{String,Any}("configurationType" => configurationType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_configurations(
configurationType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"ListConfigurations",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationType" => configurationType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_server_neighbors(configuration_id)
list_server_neighbors(configuration_id, params::Dict{String,<:Any})
Retrieves a list of servers that are one network hop away from a specified server.
# Arguments
- `configuration_id`: Configuration ID of the server for which neighbors are being listed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Maximum number of results to return in a single page of output.
- `"neighborConfigurationIds"`: List of configuration IDs to test for one-hop-away.
- `"nextToken"`: Token to retrieve the next set of results. For example, if you previously
specified 100 IDs for ListServerNeighborsRequestneighborConfigurationIds but set
ListServerNeighborsRequestmaxResults to 10, you received a set of 10 results along with a
token. Use that token in this query to get the next set of 10.
- `"portInformationNeeded"`: Flag to indicate if port and protocol information is needed as
part of the response.
"""
function list_server_neighbors(
configurationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"ListServerNeighbors",
Dict{String,Any}("configurationId" => configurationId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_server_neighbors(
configurationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"ListServerNeighbors",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationId" => configurationId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_batch_delete_configuration_task(configuration_ids, configuration_type)
start_batch_delete_configuration_task(configuration_ids, configuration_type, params::Dict{String,<:Any})
Takes a list of configurationId as input and starts an asynchronous deletion task to
remove the configurationItems. Returns a unique deletion task identifier.
# Arguments
- `configuration_ids`: The list of configuration IDs that will be deleted by the task.
- `configuration_type`: The type of configuration item to delete. Supported types are:
SERVER.
"""
function start_batch_delete_configuration_task(
configurationIds, configurationType; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StartBatchDeleteConfigurationTask",
Dict{String,Any}(
"configurationIds" => configurationIds, "configurationType" => configurationType
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_batch_delete_configuration_task(
configurationIds,
configurationType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"StartBatchDeleteConfigurationTask",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configurationIds" => configurationIds,
"configurationType" => configurationType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_continuous_export()
start_continuous_export(params::Dict{String,<:Any})
Start the continuous flow of agent's discovered data into Amazon Athena.
"""
function start_continuous_export(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"StartContinuousExport"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function start_continuous_export(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StartContinuousExport",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_data_collection_by_agent_ids(agent_ids)
start_data_collection_by_agent_ids(agent_ids, params::Dict{String,<:Any})
Instructs the specified agents to start collecting data.
# Arguments
- `agent_ids`: The IDs of the agents from which to start collecting data. If you send a
request to an agent ID that you do not have permission to contact, according to your Amazon
Web Services account, the service does not throw an exception. Instead, it returns the
error in the Description field. If you send a request to multiple agents and you do not
have permission to contact some of those agents, the system does not throw an exception.
Instead, the system shows Failed in the Description field.
"""
function start_data_collection_by_agent_ids(
agentIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StartDataCollectionByAgentIds",
Dict{String,Any}("agentIds" => agentIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_data_collection_by_agent_ids(
agentIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"StartDataCollectionByAgentIds",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("agentIds" => agentIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_export_task()
start_export_task(params::Dict{String,<:Any})
Begins the export of a discovered data report to an Amazon S3 bucket managed by Amazon Web
Services. Exports might provide an estimate of fees and savings based on certain
information that you provide. Fee estimates do not include any taxes that might apply. Your
actual fees and savings depend on a variety of factors, including your actual usage of
Amazon Web Services services, which might vary from the estimates provided in this report.
If you do not specify preferences or agentIds in the filter, a summary of all servers,
applications, tags, and performance is generated. This data is an aggregation of all server
data collected through on-premises tooling, file import, application grouping and applying
tags. If you specify agentIds in a filter, the task exports up to 72 hours of detailed data
collected by the identified Application Discovery Agent, including network, process, and
performance details. A time range for exported agent data may be set by using startTime and
endTime. Export of detailed agent data is limited to five concurrently running exports.
Export of detailed agent data is limited to two exports per day. If you enable
ec2RecommendationsPreferences in preferences , an Amazon EC2 instance matching the
characteristics of each server in Application Discovery Service is generated. Changing the
attributes of the ec2RecommendationsPreferences changes the criteria of the recommendation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"endTime"`: The end timestamp for exported data from the single Application Discovery
Agent selected in the filters. If no value is specified, exported data includes the most
recent data collected by the agent.
- `"exportDataFormat"`: The file format for the returned export data. Default value is CSV.
Note: The GRAPHML option has been deprecated.
- `"filters"`: If a filter is present, it selects the single agentId of the Application
Discovery Agent for which data is exported. The agentId can be found in the results of the
DescribeAgents API or CLI. If no filter is present, startTime and endTime are ignored and
exported data includes both Amazon Web Services Application Discovery Service Agentless
Collector collectors data and summary data from Application Discovery Agent agents.
- `"preferences"`: Indicates the type of data that needs to be exported. Only one
ExportPreferences can be enabled at any time.
- `"startTime"`: The start timestamp for exported data from the single Application
Discovery Agent selected in the filters. If no value is specified, data is exported
starting from the first data collected by the agent.
"""
function start_export_task(; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"StartExportTask"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function start_export_task(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StartExportTask", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
start_import_task(import_url, name)
start_import_task(import_url, name, params::Dict{String,<:Any})
Starts an import task, which allows you to import details of your on-premises environment
directly into Amazon Web Services Migration Hub without having to use the Amazon Web
Services Application Discovery Service (Application Discovery Service) tools such as the
Amazon Web Services Application Discovery Service Agentless Collector or Application
Discovery Agent. This gives you the option to perform migration assessment and planning
directly from your imported data, including the ability to group your devices as
applications and track their migration status. To start an import request, do this:
Download the specially formatted comma separated value (CSV) import template, which you can
find here:
https://s3.us-west-2.amazonaws.com/templates-7cffcf56-bd96-4b1c-b45b-a5b42f282e46/import_tem
plate.csv. Fill out the template with your server and application data. Upload your
import file to an Amazon S3 bucket, and make a note of it's Object URL. Your import file
must be in the CSV format. Use the console or the StartImportTask command with the Amazon
Web Services CLI or one of the Amazon Web Services SDKs to import the records from your
file. For more information, including step-by-step procedures, see Migration Hub Import
in the Amazon Web Services Application Discovery Service User Guide. There are limits to
the number of import tasks you can create (and delete) in an Amazon Web Services account.
For more information, see Amazon Web Services Application Discovery Service Limits in the
Amazon Web Services Application Discovery Service User Guide.
# Arguments
- `import_url`: The URL for your import file that you've uploaded to Amazon S3. If you're
using the Amazon Web Services CLI, this URL is structured as follows:
s3://BucketName/ImportFileName.CSV
- `name`: A descriptive name for this request. You can use this name to filter future
requests related to this import task, such as identifying applications and servers that
were included in this import task. We recommend that you use a meaningful name for each
import task.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: Optional. A unique token that you can provide to prevent the same
import request from occurring more than once. If you don't provide a token, a token is
automatically generated. Sending more than one StartImportTask request with the same client
request token will return information about the original import task with that client
request token.
"""
function start_import_task(
importUrl, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StartImportTask",
Dict{String,Any}(
"importUrl" => importUrl,
"name" => name,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_import_task(
importUrl,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"StartImportTask",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"importUrl" => importUrl,
"name" => name,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_continuous_export(export_id)
stop_continuous_export(export_id, params::Dict{String,<:Any})
Stop the continuous flow of agent's discovered data into Amazon Athena.
# Arguments
- `export_id`: The unique ID assigned to this export.
"""
function stop_continuous_export(exportId; aws_config::AbstractAWSConfig=global_aws_config())
return application_discovery_service(
"StopContinuousExport",
Dict{String,Any}("exportId" => exportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_continuous_export(
exportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"StopContinuousExport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("exportId" => exportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_data_collection_by_agent_ids(agent_ids)
stop_data_collection_by_agent_ids(agent_ids, params::Dict{String,<:Any})
Instructs the specified agents to stop collecting data.
# Arguments
- `agent_ids`: The IDs of the agents from which to stop collecting data.
"""
function stop_data_collection_by_agent_ids(
agentIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"StopDataCollectionByAgentIds",
Dict{String,Any}("agentIds" => agentIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_data_collection_by_agent_ids(
agentIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"StopDataCollectionByAgentIds",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("agentIds" => agentIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application(configuration_id)
update_application(configuration_id, params::Dict{String,<:Any})
Updates metadata about an application.
# Arguments
- `configuration_id`: Configuration ID of the application to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: New description of the application to be updated.
- `"name"`: New name of the application to be updated.
"""
function update_application(
configurationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_discovery_service(
"UpdateApplication",
Dict{String,Any}("configurationId" => configurationId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_application(
configurationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_discovery_service(
"UpdateApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("configurationId" => configurationId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 53381 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: application_insights
using AWS.Compat
using AWS.UUIDs
"""
add_workload(component_name, resource_group_name, workload_configuration)
add_workload(component_name, resource_group_name, workload_configuration, params::Dict{String,<:Any})
Adds a workload to a component. Each component can have at most five workloads.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `workload_configuration`: The configuration settings of the workload. The value is the
escaped JSON of the configuration.
"""
function add_workload(
ComponentName,
ResourceGroupName,
WorkloadConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"AddWorkload",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadConfiguration" => WorkloadConfiguration,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_workload(
ComponentName,
ResourceGroupName,
WorkloadConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"AddWorkload",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadConfiguration" => WorkloadConfiguration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_application()
create_application(params::Dict{String,<:Any})
Adds an application that is created from a resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AttachMissingPermission"`: If set to true, the managed policies for SSM and CW will be
attached to the instance roles if they are missing.
- `"AutoConfigEnabled"`: Indicates whether Application Insights automatically configures
unmonitored resources in the resource group.
- `"AutoCreate"`: Configures all of the resources in the resource group by applying the
recommended configurations.
- `"CWEMonitorEnabled"`: Indicates whether Application Insights can listen to CloudWatch
events for the application resources, such as instance terminated, failed deployment, and
others.
- `"GroupingType"`: Application Insights can create applications based on a resource group
or on an account. To create an account-based application using all of the resources in the
account, set this parameter to ACCOUNT_BASED.
- `"OpsCenterEnabled"`: When set to true, creates opsItems for any problems detected on an
application.
- `"OpsItemSNSTopicArn"`: The SNS topic provided to Application Insights that is
associated to the created opsItem. Allows you to receive notifications for updates to the
opsItem.
- `"ResourceGroupName"`: The name of the resource group.
- `"Tags"`: List of tags to add to the application. tag key (Key) and an associated tag
value (Value). The maximum length of a tag key is 128 characters. The maximum length of a
tag value is 256 characters.
"""
function create_application(; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"CreateApplication"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function create_application(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"CreateApplication", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
create_component(component_name, resource_group_name, resource_list)
create_component(component_name, resource_group_name, resource_list, params::Dict{String,<:Any})
Creates a custom component by grouping similar standalone instances to monitor.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `resource_list`: The list of resource ARNs that belong to the component.
"""
function create_component(
ComponentName,
ResourceGroupName,
ResourceList;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"CreateComponent",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"ResourceList" => ResourceList,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_component(
ComponentName,
ResourceGroupName,
ResourceList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"CreateComponent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"ResourceList" => ResourceList,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_log_pattern(pattern, pattern_name, pattern_set_name, rank, resource_group_name)
create_log_pattern(pattern, pattern_name, pattern_set_name, rank, resource_group_name, params::Dict{String,<:Any})
Adds an log pattern to a LogPatternSet.
# Arguments
- `pattern`: The log pattern. The pattern must be DFA compatible. Patterns that utilize
forward lookahead or backreference constructions are not supported.
- `pattern_name`: The name of the log pattern.
- `pattern_set_name`: The name of the log pattern set.
- `rank`: Rank of the log pattern. Must be a value between 1 and 1,000,000. The patterns
are sorted by rank, so we recommend that you set your highest priority patterns with the
lowest rank. A pattern of rank 1 will be the first to get matched to a log line. A pattern
of rank 1,000,000 will be last to get matched. When you configure custom log patterns from
the console, a Low severity pattern translates to a 750,000 rank. A Medium severity pattern
translates to a 500,000 rank. And a High severity pattern translates to a 250,000 rank.
Rank values less than 1 or greater than 1,000,000 are reserved for AWS-provided patterns.
- `resource_group_name`: The name of the resource group.
"""
function create_log_pattern(
Pattern,
PatternName,
PatternSetName,
Rank,
ResourceGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"CreateLogPattern",
Dict{String,Any}(
"Pattern" => Pattern,
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"Rank" => Rank,
"ResourceGroupName" => ResourceGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_log_pattern(
Pattern,
PatternName,
PatternSetName,
Rank,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"CreateLogPattern",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Pattern" => Pattern,
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"Rank" => Rank,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_application(resource_group_name)
delete_application(resource_group_name, params::Dict{String,<:Any})
Removes the specified application from monitoring. Does not delete the application.
# Arguments
- `resource_group_name`: The name of the resource group.
"""
function delete_application(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DeleteApplication",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_application(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DeleteApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_component(component_name, resource_group_name)
delete_component(component_name, resource_group_name, params::Dict{String,<:Any})
Ungroups a custom component. When you ungroup custom components, all applicable monitors
that are set up for the component are removed and the instances revert to their standalone
status.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
"""
function delete_component(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DeleteComponent",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_component(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DeleteComponent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_log_pattern(pattern_name, pattern_set_name, resource_group_name)
delete_log_pattern(pattern_name, pattern_set_name, resource_group_name, params::Dict{String,<:Any})
Removes the specified log pattern from a LogPatternSet.
# Arguments
- `pattern_name`: The name of the log pattern.
- `pattern_set_name`: The name of the log pattern set.
- `resource_group_name`: The name of the resource group.
"""
function delete_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DeleteLogPattern",
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DeleteLogPattern",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_application(resource_group_name)
describe_application(resource_group_name, params::Dict{String,<:Any})
Describes the application.
# Arguments
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_application(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DescribeApplication",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_application(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_component(component_name, resource_group_name)
describe_component(component_name, resource_group_name, params::Dict{String,<:Any})
Describes a component and lists the resources that are grouped together in a component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_component(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DescribeComponent",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_component(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeComponent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_component_configuration(component_name, resource_group_name)
describe_component_configuration(component_name, resource_group_name, params::Dict{String,<:Any})
Describes the monitoring configuration of the component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_component_configuration(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DescribeComponentConfiguration",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_component_configuration(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeComponentConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_component_configuration_recommendation(component_name, resource_group_name, tier)
describe_component_configuration_recommendation(component_name, resource_group_name, tier, params::Dict{String,<:Any})
Describes the recommended monitoring configuration of the component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `tier`: The tier of the application component.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RecommendationType"`: The recommended configuration type.
- `"WorkloadName"`: The name of the workload.
"""
function describe_component_configuration_recommendation(
ComponentName,
ResourceGroupName,
Tier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeComponentConfigurationRecommendation",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"Tier" => Tier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_component_configuration_recommendation(
ComponentName,
ResourceGroupName,
Tier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeComponentConfigurationRecommendation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"Tier" => Tier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_log_pattern(pattern_name, pattern_set_name, resource_group_name)
describe_log_pattern(pattern_name, pattern_set_name, resource_group_name, params::Dict{String,<:Any})
Describe a specific log pattern from a LogPatternSet.
# Arguments
- `pattern_name`: The name of the log pattern.
- `pattern_set_name`: The name of the log pattern set.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeLogPattern",
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeLogPattern",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_observation(observation_id)
describe_observation(observation_id, params::Dict{String,<:Any})
Describes an anomaly or error with the application.
# Arguments
- `observation_id`: The ID of the observation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_observation(
ObservationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DescribeObservation",
Dict{String,Any}("ObservationId" => ObservationId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_observation(
ObservationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeObservation",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ObservationId" => ObservationId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_problem(problem_id)
describe_problem(problem_id, params::Dict{String,<:Any})
Describes an application problem.
# Arguments
- `problem_id`: The ID of the problem.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the owner of the resource group affected by the
problem.
"""
function describe_problem(ProblemId; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"DescribeProblem",
Dict{String,Any}("ProblemId" => ProblemId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_problem(
ProblemId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeProblem",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ProblemId" => ProblemId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_problem_observations(problem_id)
describe_problem_observations(problem_id, params::Dict{String,<:Any})
Describes the anomalies or errors associated with the problem.
# Arguments
- `problem_id`: The ID of the problem.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
"""
function describe_problem_observations(
ProblemId; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"DescribeProblemObservations",
Dict{String,Any}("ProblemId" => ProblemId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_problem_observations(
ProblemId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeProblemObservations",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ProblemId" => ProblemId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_workload(component_name, resource_group_name, workload_id)
describe_workload(component_name, resource_group_name, workload_id, params::Dict{String,<:Any})
Describes a workload and its configuration.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `workload_id`: The ID of the workload.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the workload owner.
"""
function describe_workload(
ComponentName,
ResourceGroupName,
WorkloadId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeWorkload",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadId" => WorkloadId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_workload(
ComponentName,
ResourceGroupName,
WorkloadId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"DescribeWorkload",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadId" => WorkloadId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_applications()
list_applications(params::Dict{String,<:Any})
Lists the IDs of the applications that you are monitoring.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
"""
function list_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"ListApplications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListApplications", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_components(resource_group_name)
list_components(resource_group_name, params::Dict{String,<:Any})
Lists the auto-grouped, standalone, and custom components of the application.
# Arguments
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
"""
function list_components(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListComponents",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_components(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"ListComponents",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configuration_history()
list_configuration_history(params::Dict{String,<:Any})
Lists the INFO, WARN, and ERROR events for periodic configuration updates performed by
Application Insights. Examples of events represented are: INFO: creating a new alarm or
updating an alarm threshold. WARN: alarm not created due to insufficient data points used
to predict thresholds. ERROR: alarm not created due to permission errors or exceeding
quotas.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"EndTime"`: The end time of the event.
- `"EventStatus"`: The status of the configuration update event. Possible values include
INFO, WARN, and ERROR.
- `"MaxResults"`: The maximum number of results returned by ListConfigurationHistory in
paginated output. When this parameter is used, ListConfigurationHistory returns only
MaxResults in a single page along with a NextToken response element. The remaining results
of the initial request can be seen by sending another ListConfigurationHistory request with
the returned NextToken value. If this parameter is not used, then ListConfigurationHistory
returns all results.
- `"NextToken"`: The NextToken value returned from a previous paginated
ListConfigurationHistory request where MaxResults was used and the results exceeded the
value of that parameter. Pagination continues from the end of the previous results that
returned the NextToken value. This value is null when there are no more results to return.
- `"ResourceGroupName"`: Resource group to which the application belongs.
- `"StartTime"`: The start time of the event.
"""
function list_configuration_history(; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"ListConfigurationHistory"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_configuration_history(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListConfigurationHistory",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_log_pattern_sets(resource_group_name)
list_log_pattern_sets(resource_group_name, params::Dict{String,<:Any})
Lists the log pattern sets in the specific application.
# Arguments
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
"""
function list_log_pattern_sets(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListLogPatternSets",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_log_pattern_sets(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"ListLogPatternSets",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_log_patterns(resource_group_name)
list_log_patterns(resource_group_name, params::Dict{String,<:Any})
Lists the log patterns in the specific log LogPatternSet.
# Arguments
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
- `"PatternSetName"`: The name of the log pattern set.
"""
function list_log_patterns(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListLogPatterns",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_log_patterns(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"ListLogPatterns",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_problems()
list_problems(params::Dict{String,<:Any})
Lists the problems with your application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID for the resource group owner.
- `"ComponentName"`: The name of the component.
- `"EndTime"`: The time when the problem ended, in epoch seconds. If not specified,
problems within the past seven days are returned.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
- `"ResourceGroupName"`: The name of the resource group.
- `"StartTime"`: The time when the problem was detected, in epoch seconds. If you don't
specify a time frame for the request, problems within the past seven days are returned.
- `"Visibility"`: Specifies whether or not you can view the problem. If not specified,
visible and ignored problems are returned.
"""
function list_problems(; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"ListProblems"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_problems(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListProblems", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieve a list of the tags (keys and values) that are associated with a specified
application. A tag is a label that you optionally define and associate with an application.
Each tag consists of a required tag key and an optional associated tag value. A tag key is
a general label that acts as a category for more specific tag values. A tag value acts as a
descriptor within a tag key.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the application that you want to
retrieve tag information for.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_workloads(component_name, resource_group_name)
list_workloads(component_name, resource_group_name, params::Dict{String,<:Any})
Lists the workloads that are configured on a given component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The AWS account ID of the owner of the workload.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned NextToken value.
- `"NextToken"`: The token to request the next page of results.
"""
function list_workloads(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"ListWorkloads",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_workloads(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"ListWorkloads",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_workload(component_name, resource_group_name, workload_id)
remove_workload(component_name, resource_group_name, workload_id, params::Dict{String,<:Any})
Remove workload from a component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `workload_id`: The ID of the workload.
"""
function remove_workload(
ComponentName,
ResourceGroupName,
WorkloadId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"RemoveWorkload",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadId" => WorkloadId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_workload(
ComponentName,
ResourceGroupName,
WorkloadId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"RemoveWorkload",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadId" => WorkloadId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Add one or more tags (keys and values) to a specified application. A tag is a label that
you optionally define and associate with an application. Tags can help you categorize and
manage application in different ways, such as by purpose, owner, environment, or other
criteria. Each tag consists of a required tag key and an associated tag value, both of
which you define. A tag key is a general label that acts as a category for more specific
tag values. A tag value acts as a descriptor within a tag key.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the application that you want to add
one or more tags to.
- `tags`: A list of tags that to add to the application. A tag consists of a required tag
key (Key) and an associated tag value (Value). The maximum length of a tag key is 128
characters. The maximum length of a tag value is 256 characters.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Remove one or more tags (keys and values) from a specified application.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the application that you want to remove
one or more tags from.
- `tag_keys`: The tags (tag keys) that you want to remove from the resource. When you
specify a tag key, the action removes both that key and its associated tag value. To remove
more than one tag from the application, append the TagKeys parameter and argument for each
additional tag to remove, separated by an ampersand.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application(resource_group_name)
update_application(resource_group_name, params::Dict{String,<:Any})
Updates the application.
# Arguments
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AttachMissingPermission"`: If set to true, the managed policies for SSM and CW will be
attached to the instance roles if they are missing.
- `"AutoConfigEnabled"`: Turns auto-configuration on or off.
- `"CWEMonitorEnabled"`: Indicates whether Application Insights can listen to CloudWatch
events for the application resources, such as instance terminated, failed deployment, and
others.
- `"OpsCenterEnabled"`: When set to true, creates opsItems for any problems detected on an
application.
- `"OpsItemSNSTopicArn"`: The SNS topic provided to Application Insights that is
associated to the created opsItem. Allows you to receive notifications for updates to the
opsItem.
- `"RemoveSNSTopic"`: Disassociates the SNS topic from the opsItem created for detected
problems.
"""
function update_application(
ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"UpdateApplication",
Dict{String,Any}("ResourceGroupName" => ResourceGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_application(
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ResourceGroupName" => ResourceGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_component(component_name, resource_group_name)
update_component(component_name, resource_group_name, params::Dict{String,<:Any})
Updates the custom component name and/or the list of resources that make up the component.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NewComponentName"`: The new name of the component.
- `"ResourceList"`: The list of resource ARNs that belong to the component.
"""
function update_component(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"UpdateComponent",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_component(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateComponent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_component_configuration(component_name, resource_group_name)
update_component_configuration(component_name, resource_group_name, params::Dict{String,<:Any})
Updates the monitoring configurations for the component. The configuration input parameter
is an escaped JSON of the configuration and should match the schema of what is returned by
DescribeComponentConfigurationRecommendation.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoConfigEnabled"`: Automatically configures the component by applying the
recommended configurations.
- `"ComponentConfiguration"`: The configuration settings of the component. The value is the
escaped JSON of the configuration. For more information about the JSON format, see Working
with JSON. You can send a request to DescribeComponentConfigurationRecommendation to see
the recommended configuration for a component. For the complete format of the component
configuration file, see Component Configuration.
- `"Monitor"`: Indicates whether the application component is monitored.
- `"Tier"`: The tier of the application component.
"""
function update_component_configuration(
ComponentName, ResourceGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_insights(
"UpdateComponentConfiguration",
Dict{String,Any}(
"ComponentName" => ComponentName, "ResourceGroupName" => ResourceGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_component_configuration(
ComponentName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateComponentConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_log_pattern(pattern_name, pattern_set_name, resource_group_name)
update_log_pattern(pattern_name, pattern_set_name, resource_group_name, params::Dict{String,<:Any})
Adds a log pattern to a LogPatternSet.
# Arguments
- `pattern_name`: The name of the log pattern.
- `pattern_set_name`: The name of the log pattern set.
- `resource_group_name`: The name of the resource group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Pattern"`: The log pattern. The pattern must be DFA compatible. Patterns that utilize
forward lookahead or backreference constructions are not supported.
- `"Rank"`: Rank of the log pattern. Must be a value between 1 and 1,000,000. The patterns
are sorted by rank, so we recommend that you set your highest priority patterns with the
lowest rank. A pattern of rank 1 will be the first to get matched to a log line. A pattern
of rank 1,000,000 will be last to get matched. When you configure custom log patterns from
the console, a Low severity pattern translates to a 750,000 rank. A Medium severity pattern
translates to a 500,000 rank. And a High severity pattern translates to a 250,000 rank.
Rank values less than 1 or greater than 1,000,000 are reserved for AWS-provided patterns.
"""
function update_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateLogPattern",
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_log_pattern(
PatternName,
PatternSetName,
ResourceGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateLogPattern",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PatternName" => PatternName,
"PatternSetName" => PatternSetName,
"ResourceGroupName" => ResourceGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_problem(problem_id)
update_problem(problem_id, params::Dict{String,<:Any})
Updates the visibility of the problem or specifies the problem as RESOLVED.
# Arguments
- `problem_id`: The ID of the problem.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"UpdateStatus"`: The status of the problem. Arguments can be passed for only problems
that show a status of RECOVERING.
- `"Visibility"`: The visibility of a problem. When you pass a value of IGNORED, the
problem is removed from the default view, and all notifications for the problem are
suspended. When VISIBLE is passed, the IGNORED action is reversed.
"""
function update_problem(ProblemId; aws_config::AbstractAWSConfig=global_aws_config())
return application_insights(
"UpdateProblem",
Dict{String,Any}("ProblemId" => ProblemId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_problem(
ProblemId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateProblem",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ProblemId" => ProblemId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_workload(component_name, resource_group_name, workload_configuration)
update_workload(component_name, resource_group_name, workload_configuration, params::Dict{String,<:Any})
Adds a workload to a component. Each component can have at most five workloads.
# Arguments
- `component_name`: The name of the component.
- `resource_group_name`: The name of the resource group.
- `workload_configuration`: The configuration settings of the workload. The value is the
escaped JSON of the configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"WorkloadId"`: The ID of the workload.
"""
function update_workload(
ComponentName,
ResourceGroupName,
WorkloadConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateWorkload",
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadConfiguration" => WorkloadConfiguration,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_workload(
ComponentName,
ResourceGroupName,
WorkloadConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_insights(
"UpdateWorkload",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ComponentName" => ComponentName,
"ResourceGroupName" => ResourceGroupName,
"WorkloadConfiguration" => WorkloadConfiguration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 30306 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: application_signals
using AWS.Compat
using AWS.UUIDs
"""
batch_get_service_level_objective_budget_report(slo_ids, timestamp)
batch_get_service_level_objective_budget_report(slo_ids, timestamp, params::Dict{String,<:Any})
Use this operation to retrieve one or more service level objective (SLO) budget reports. An
error budget is the amount of time in unhealthy periods that your service can accumulate
during an interval before your overall SLO budget health is breached and the SLO is
considered to be unmet. For example, an SLO with a threshold of 99.95% and a monthly
interval translates to an error budget of 21.9 minutes of downtime in a 30-day month.
Budget reports include a health indicator, the attainment value, and remaining budget. For
more information about SLO error budgets, see SLO concepts.
# Arguments
- `slo_ids`: An array containing the IDs of the service level objectives that you want to
include in the report.
- `timestamp`: The date and time that you want the report to be for. It is expressed as the
number of milliseconds since Jan 1, 1970 00:00:00 UTC.
"""
function batch_get_service_level_objective_budget_report(
SloIds, Timestamp; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/budget-report",
Dict{String,Any}("SloIds" => SloIds, "Timestamp" => Timestamp);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_service_level_objective_budget_report(
SloIds,
Timestamp,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/budget-report",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("SloIds" => SloIds, "Timestamp" => Timestamp),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_service_level_objective(name, sli_config)
create_service_level_objective(name, sli_config, params::Dict{String,<:Any})
Creates a service level objective (SLO), which can help you ensure that your critical
business operations are meeting customer expectations. Use SLOs to set and track specific
target levels for the reliability and availability of your applications and services. SLOs
use service level indicators (SLIs) to calculate whether the application is performing at
the level that you want. Create an SLO to set a target for a service or operation’s
availability or latency. CloudWatch measures this target frequently you can find whether it
has been breached. When you create an SLO, you set an attainment goal for it. An
attainment goal is the ratio of good periods that meet the threshold requirements to the
total periods within the interval. For example, an attainment goal of 99.9% means that
within your interval, you are targeting 99.9% of the periods to be in healthy state. After
you have created an SLO, you can retrieve error budget reports for it. An error budget is
the number of periods or amount of time that your service can accumulate during an interval
before your overall SLO budget health is breached and the SLO is considered to be unmet.
for example, an SLO with a threshold that 99.95% of requests must be completed under 2000ms
every month translates to an error budget of 21.9 minutes of downtime per month. When you
call this operation, Application Signals creates the
AWSServiceRoleForCloudWatchApplicationSignals service-linked role, if it doesn't already
exist in your account. This service- linked role has the following permissions:
xray:GetServiceGraph logs:StartQuery logs:GetQueryResults
cloudwatch:GetMetricData cloudwatch:ListMetrics tag:GetResources
autoscaling:DescribeAutoScalingGroups You can easily set SLO targets for your
applications that are discovered by Application Signals, using critical metrics such as
latency and availability. You can also set SLOs against any CloudWatch metric or math
expression that produces a time series. For more information about SLOs, see Service level
objectives (SLOs).
# Arguments
- `name`: A name for this SLO.
- `sli_config`: A structure that contains information about what service and what
performance metric that this SLO will monitor.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: An optional description for this SLO.
- `"Goal"`: A structure that contains the attributes that determine the goal of the SLO.
This includes the time period for evaluation and the attainment threshold.
- `"Tags"`: A list of key-value pairs to associate with the SLO. You can associate as many
as 50 tags with an SLO. To be able to associate tags with the SLO when you create the SLO,
you must have the cloudwatch:TagResource permission. Tags can help you organize and
categorize your resources. You can also use them to scope user permissions by granting a
user permission to access or change only resources with certain tag values.
"""
function create_service_level_objective(
Name, SliConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/slo",
Dict{String,Any}("Name" => Name, "SliConfig" => SliConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_service_level_objective(
Name,
SliConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/slo",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "SliConfig" => SliConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_service_level_objective(id)
delete_service_level_objective(id, params::Dict{String,<:Any})
Deletes the specified service level objective.
# Arguments
- `id`: The ARN or name of the service level objective to delete.
"""
function delete_service_level_objective(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"DELETE", "/slo/$(Id)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function delete_service_level_objective(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"DELETE",
"/slo/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_service(end_time, key_attributes, start_time)
get_service(end_time, key_attributes, start_time, params::Dict{String,<:Any})
Returns information about a service discovered by Application Signals.
# Arguments
- `end_time`: The end of the time period to retrieve information about. When used in a raw
HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
- `key_attributes`: Use this field to specify which service you want to retrieve
information for. You must specify at least the Type, Name, and Environment attributes. This
is a string-to-string map. It can include the following fields. Type designates the type
of object this is. ResourceType specifies the type of the resource. This field is used
only when the value of the Type field is Resource or AWS::Resource. Name specifies the
name of the object. This is used only if the value of the Type field is Service,
RemoteService, or AWS::Service. Identifier identifies the resource objects of this
resource. This is used only if the value of the Type field is Resource or AWS::Resource.
Environment specifies the location where this object is hosted, or what it belongs to.
- `start_time`: The start of the time period to retrieve information about. When used in a
raw HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
"""
function get_service(
EndTime, KeyAttributes, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/service",
Dict{String,Any}(
"EndTime" => EndTime, "KeyAttributes" => KeyAttributes, "StartTime" => StartTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_service(
EndTime,
KeyAttributes,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/service",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"KeyAttributes" => KeyAttributes,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_service_level_objective(id)
get_service_level_objective(id, params::Dict{String,<:Any})
Returns information about one SLO created in the account.
# Arguments
- `id`: The ARN or name of the SLO that you want to retrieve information about. You can
find the ARNs of SLOs by using the ListServiceLevelObjectives operation.
"""
function get_service_level_objective(Id; aws_config::AbstractAWSConfig=global_aws_config())
return application_signals(
"GET", "/slo/$(Id)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_service_level_objective(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"GET", "/slo/$(Id)", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_service_dependencies(end_time, key_attributes, start_time)
list_service_dependencies(end_time, key_attributes, start_time, params::Dict{String,<:Any})
Returns a list of service dependencies of the service that you specify. A dependency is an
infrastructure component that an operation of this service connects with. Dependencies can
include Amazon Web Services services, Amazon Web Services resources, and third-party
services.
# Arguments
- `end_time`: The end of the time period to retrieve information about. When used in a raw
HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
- `key_attributes`: Use this field to specify which service you want to retrieve
information for. You must specify at least the Type, Name, and Environment attributes. This
is a string-to-string map. It can include the following fields. Type designates the type
of object this is. ResourceType specifies the type of the resource. This field is used
only when the value of the Type field is Resource or AWS::Resource. Name specifies the
name of the object. This is used only if the value of the Type field is Service,
RemoteService, or AWS::Service. Identifier identifies the resource objects of this
resource. This is used only if the value of the Type field is Resource or AWS::Resource.
Environment specifies the location where this object is hosted, or what it belongs to.
- `start_time`: The start of the time period to retrieve information about. When used in a
raw HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 50 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of service dependencies.
"""
function list_service_dependencies(
EndTime, KeyAttributes, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/service-dependencies",
Dict{String,Any}(
"EndTime" => EndTime, "KeyAttributes" => KeyAttributes, "StartTime" => StartTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_service_dependencies(
EndTime,
KeyAttributes,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/service-dependencies",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"KeyAttributes" => KeyAttributes,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_service_dependents(end_time, key_attributes, start_time)
list_service_dependents(end_time, key_attributes, start_time, params::Dict{String,<:Any})
Returns the list of dependents that invoked the specified service during the provided time
range. Dependents include other services, CloudWatch Synthetics canaries, and clients that
are instrumented with CloudWatch RUM app monitors.
# Arguments
- `end_time`: The end of the time period to retrieve information about. When used in a raw
HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
- `key_attributes`: Use this field to specify which service you want to retrieve
information for. You must specify at least the Type, Name, and Environment attributes. This
is a string-to-string map. It can include the following fields. Type designates the type
of object this is. ResourceType specifies the type of the resource. This field is used
only when the value of the Type field is Resource or AWS::Resource. Name specifies the
name of the object. This is used only if the value of the Type field is Service,
RemoteService, or AWS::Service. Identifier identifies the resource objects of this
resource. This is used only if the value of the Type field is Resource or AWS::Resource.
Environment specifies the location where this object is hosted, or what it belongs to.
- `start_time`: The start of the time period to retrieve information about. When used in a
raw HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 50 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of service dependents.
"""
function list_service_dependents(
EndTime, KeyAttributes, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/service-dependents",
Dict{String,Any}(
"EndTime" => EndTime, "KeyAttributes" => KeyAttributes, "StartTime" => StartTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_service_dependents(
EndTime,
KeyAttributes,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/service-dependents",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"KeyAttributes" => KeyAttributes,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_service_level_objectives()
list_service_level_objectives(params::Dict{String,<:Any})
Returns a list of SLOs created in this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"KeyAttributes"`: You can use this optional field to specify which services you want to
retrieve SLO information for. This is a string-to-string map. It can include the following
fields. Type designates the type of object this is. ResourceType specifies the type
of the resource. This field is used only when the value of the Type field is Resource or
AWS::Resource. Name specifies the name of the object. This is used only if the value of
the Type field is Service, RemoteService, or AWS::Service. Identifier identifies the
resource objects of this resource. This is used only if the value of the Type field is
Resource or AWS::Resource. Environment specifies the location where this object is
hosted, or what it belongs to.
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 50 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of service level objectives.
- `"OperationName"`: The name of the operation that this SLO is associated with.
"""
function list_service_level_objectives(; aws_config::AbstractAWSConfig=global_aws_config())
return application_signals(
"POST", "/slos"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_service_level_objectives(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST", "/slos", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_service_operations(end_time, key_attributes, start_time)
list_service_operations(end_time, key_attributes, start_time, params::Dict{String,<:Any})
Returns a list of the operations of this service that have been discovered by Application
Signals. Only the operations that were invoked during the specified time range are returned.
# Arguments
- `end_time`: The end of the time period to retrieve information about. When used in a raw
HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
- `key_attributes`: Use this field to specify which service you want to retrieve
information for. You must specify at least the Type, Name, and Environment attributes. This
is a string-to-string map. It can include the following fields. Type designates the type
of object this is. ResourceType specifies the type of the resource. This field is used
only when the value of the Type field is Resource or AWS::Resource. Name specifies the
name of the object. This is used only if the value of the Type field is Service,
RemoteService, or AWS::Service. Identifier identifies the resource objects of this
resource. This is used only if the value of the Type field is Resource or AWS::Resource.
Environment specifies the location where this object is hosted, or what it belongs to.
- `start_time`: The start of the time period to retrieve information about. When used in a
raw HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 50 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of service operations.
"""
function list_service_operations(
EndTime, KeyAttributes, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/service-operations",
Dict{String,Any}(
"EndTime" => EndTime, "KeyAttributes" => KeyAttributes, "StartTime" => StartTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_service_operations(
EndTime,
KeyAttributes,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/service-operations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"KeyAttributes" => KeyAttributes,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_services(end_time, start_time)
list_services(end_time, start_time, params::Dict{String,<:Any})
Returns a list of services that have been discovered by Application Signals. A service
represents a minimum logical and transactional unit that completes a business function.
Services are discovered through Application Signals instrumentation.
# Arguments
- `end_time`: The end of the time period to retrieve information about. When used in a raw
HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
- `start_time`: The start of the time period to retrieve information about. When used in a
raw HTTP Query API, it is formatted as be epoch time in seconds. For example: 1698778057
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 50 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of services.
"""
function list_services(
EndTime, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"GET",
"/services",
Dict{String,Any}("EndTime" => EndTime, "StartTime" => StartTime);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_services(
EndTime,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"GET",
"/services",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("EndTime" => EndTime, "StartTime" => StartTime),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Displays the tags associated with a CloudWatch resource. Tags can be assigned to service
level objectives.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudWatch resource that you want
to view tags for. The ARN format of an Application Signals SLO is
arn:aws:cloudwatch:Region:account-id:slo:slo-name For more information about ARN format,
see Resource Types Defined by Amazon CloudWatch in the Amazon Web Services General
Reference.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"GET",
"/tags",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"GET",
"/tags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_discovery()
start_discovery(params::Dict{String,<:Any})
Enables this Amazon Web Services account to be able to use CloudWatch Application Signals
by creating the AWSServiceRoleForCloudWatchApplicationSignals service-linked role. This
service- linked role has the following permissions: xray:GetServiceGraph
logs:StartQuery logs:GetQueryResults cloudwatch:GetMetricData
cloudwatch:ListMetrics tag:GetResources autoscaling:DescribeAutoScalingGroups
After completing this step, you still need to instrument your Java and Python applications
to send data to Application Signals. For more information, see Enabling Application
Signals.
"""
function start_discovery(; aws_config::AbstractAWSConfig=global_aws_config())
return application_signals(
"POST", "/start-discovery"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function start_discovery(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/start-discovery",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns one or more tags (key-value pairs) to the specified CloudWatch resource, such as a
service level objective. Tags can help you organize and categorize your resources. You can
also use them to scope user permissions by granting a user permission to access or change
only resources with certain tag values. Tags don't have any semantic meaning to Amazon Web
Services and are interpreted strictly as strings of characters. You can use the TagResource
action with an alarm that already has tags. If you specify a new tag key for the alarm,
this tag is appended to the list of tags associated with the alarm. If you specify a tag
key that is already associated with the alarm, the new tag value that you specify replaces
the previous value for that tag. You can associate as many as 50 tags with a CloudWatch
resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudWatch resource that you want
to set tags for. The ARN format of an Application Signals SLO is
arn:aws:cloudwatch:Region:account-id:slo:slo-name For more information about ARN format,
see Resource Types Defined by Amazon CloudWatch in the Amazon Web Services General
Reference.
- `tags`: The list of key-value pairs to associate with the alarm.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return application_signals(
"POST",
"/tag-resource",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes one or more tags from the specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudWatch resource that you want
to delete tags from. The ARN format of an Application Signals SLO is
arn:aws:cloudwatch:Region:account-id:slo:slo-name For more information about ARN format,
see Resource Types Defined by Amazon CloudWatch in the Amazon Web Services General
Reference.
- `tag_keys`: The list of tag keys to remove from the resource.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"POST",
"/untag-resource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return application_signals(
"POST",
"/untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_service_level_objective(id)
update_service_level_objective(id, params::Dict{String,<:Any})
Updates an existing service level objective (SLO). If you omit parameters, the previous
values of those parameters are retained.
# Arguments
- `id`: The Amazon Resource Name (ARN) or name of the service level objective that you want
to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: An optional description for the SLO.
- `"Goal"`: A structure that contains the attributes that determine the goal of the SLO.
This includes the time period for evaluation and the attainment threshold.
- `"SliConfig"`: A structure that contains information about what performance metric this
SLO will monitor.
"""
function update_service_level_objective(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"PATCH", "/slo/$(Id)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_service_level_objective(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return application_signals(
"PATCH",
"/slo/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 8603 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: applicationcostprofiler
using AWS.Compat
using AWS.UUIDs
"""
delete_report_definition(report_id)
delete_report_definition(report_id, params::Dict{String,<:Any})
Deletes the specified report definition in AWS Application Cost Profiler. This stops the
report from being generated.
# Arguments
- `report_id`: Required. ID of the report to delete.
"""
function delete_report_definition(
reportId; aws_config::AbstractAWSConfig=global_aws_config()
)
return applicationcostprofiler(
"DELETE",
"/reportDefinition/$(reportId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_report_definition(
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"DELETE",
"/reportDefinition/$(reportId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_report_definition(report_id)
get_report_definition(report_id, params::Dict{String,<:Any})
Retrieves the definition of a report already configured in AWS Application Cost Profiler.
# Arguments
- `report_id`: ID of the report to retrieve.
"""
function get_report_definition(reportId; aws_config::AbstractAWSConfig=global_aws_config())
return applicationcostprofiler(
"GET",
"/reportDefinition/$(reportId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_report_definition(
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"GET",
"/reportDefinition/$(reportId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_application_usage(source_s3_location)
import_application_usage(source_s3_location, params::Dict{String,<:Any})
Ingests application usage data from Amazon Simple Storage Service (Amazon S3). The data
must already exist in the S3 location. As part of the action, AWS Application Cost Profiler
copies the object from your S3 bucket to an S3 bucket owned by Amazon for processing
asynchronously.
# Arguments
- `source_s3_location`: Amazon S3 location to import application usage data from.
"""
function import_application_usage(
sourceS3Location; aws_config::AbstractAWSConfig=global_aws_config()
)
return applicationcostprofiler(
"POST",
"/importApplicationUsage",
Dict{String,Any}("sourceS3Location" => sourceS3Location);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_application_usage(
sourceS3Location,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"POST",
"/importApplicationUsage",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("sourceS3Location" => sourceS3Location), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_report_definitions()
list_report_definitions(params::Dict{String,<:Any})
Retrieves a list of all reports and their configurations for your AWS account. The maximum
number of reports is one.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return.
- `"nextToken"`: The token value from a previous call to access the next page of results.
"""
function list_report_definitions(; aws_config::AbstractAWSConfig=global_aws_config())
return applicationcostprofiler(
"GET", "/reportDefinition"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_report_definitions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return applicationcostprofiler(
"GET",
"/reportDefinition",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_report_definition(destination_s3_location, format, report_description, report_frequency, report_id)
put_report_definition(destination_s3_location, format, report_description, report_frequency, report_id, params::Dict{String,<:Any})
Creates the report definition for a report in Application Cost Profiler.
# Arguments
- `destination_s3_location`: Required. Amazon Simple Storage Service (Amazon S3) location
where Application Cost Profiler uploads the report.
- `format`: Required. The format to use for the generated report.
- `report_description`: Required. Description of the report.
- `report_frequency`: Required. The cadence to generate the report.
- `report_id`: Required. ID of the report. You can choose any valid string matching the
pattern for the ID.
"""
function put_report_definition(
destinationS3Location,
format,
reportDescription,
reportFrequency,
reportId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"POST",
"/reportDefinition",
Dict{String,Any}(
"destinationS3Location" => destinationS3Location,
"format" => format,
"reportDescription" => reportDescription,
"reportFrequency" => reportFrequency,
"reportId" => reportId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_report_definition(
destinationS3Location,
format,
reportDescription,
reportFrequency,
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"POST",
"/reportDefinition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationS3Location" => destinationS3Location,
"format" => format,
"reportDescription" => reportDescription,
"reportFrequency" => reportFrequency,
"reportId" => reportId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_report_definition(destination_s3_location, format, report_description, report_frequency, report_id)
update_report_definition(destination_s3_location, format, report_description, report_frequency, report_id, params::Dict{String,<:Any})
Updates existing report in AWS Application Cost Profiler.
# Arguments
- `destination_s3_location`: Required. Amazon Simple Storage Service (Amazon S3) location
where Application Cost Profiler uploads the report.
- `format`: Required. The format to use for the generated report.
- `report_description`: Required. Description of the report.
- `report_frequency`: Required. The cadence to generate the report.
- `report_id`: Required. ID of the report to update.
"""
function update_report_definition(
destinationS3Location,
format,
reportDescription,
reportFrequency,
reportId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"PUT",
"/reportDefinition/$(reportId)",
Dict{String,Any}(
"destinationS3Location" => destinationS3Location,
"format" => format,
"reportDescription" => reportDescription,
"reportFrequency" => reportFrequency,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_report_definition(
destinationS3Location,
format,
reportDescription,
reportFrequency,
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return applicationcostprofiler(
"PUT",
"/reportDefinition/$(reportId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationS3Location" => destinationS3Location,
"format" => format,
"reportDescription" => reportDescription,
"reportFrequency" => reportFrequency,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 65932 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: apprunner
using AWS.Compat
using AWS.UUIDs
"""
associate_custom_domain(domain_name, service_arn)
associate_custom_domain(domain_name, service_arn, params::Dict{String,<:Any})
Associate your own domain name with the App Runner subdomain URL of your App Runner
service. After you call AssociateCustomDomain and receive a successful response, use the
information in the CustomDomain record that's returned to add CNAME records to your Domain
Name System (DNS). For each mapped domain name, add a mapping to the target App Runner
subdomain and one or more certificate validation records. App Runner then performs DNS
validation to verify that you own or control the domain name that you associated. App
Runner tracks domain validity in a certificate stored in AWS Certificate Manager (ACM).
# Arguments
- `domain_name`: A custom domain endpoint to associate. Specify a root domain (for example,
example.com), a subdomain (for example, login.example.com or admin.login.example.com), or a
wildcard (for example, *.example.com).
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
associate a custom domain name with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EnableWWWSubdomain"`: Set to true to associate the subdomain www.DomainName with the
App Runner service in addition to the base domain. Default: true
"""
function associate_custom_domain(
DomainName, ServiceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"AssociateCustomDomain",
Dict{String,Any}("DomainName" => DomainName, "ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_custom_domain(
DomainName,
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"AssociateCustomDomain",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "ServiceArn" => ServiceArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_auto_scaling_configuration(auto_scaling_configuration_name)
create_auto_scaling_configuration(auto_scaling_configuration_name, params::Dict{String,<:Any})
Create an App Runner automatic scaling configuration resource. App Runner requires this
resource when you create or update App Runner services and you require non-default auto
scaling settings. You can share an auto scaling configuration across multiple services.
Create multiple revisions of a configuration by calling this action multiple times using
the same AutoScalingConfigurationName. The call returns incremental
AutoScalingConfigurationRevision values. When you create a service and configure an auto
scaling configuration resource, the service uses the latest active revision of the auto
scaling configuration by default. You can optionally configure the service to use a
specific revision. Configure a higher MinSize to increase the spread of your App Runner
service over more Availability Zones in the Amazon Web Services Region. The tradeoff is a
higher minimal cost. Configure a lower MaxSize to control your cost. The tradeoff is lower
responsiveness during peak demand.
# Arguments
- `auto_scaling_configuration_name`: A name for the auto scaling configuration. When you
use it for the first time in an Amazon Web Services Region, App Runner creates revision
number 1 of this name. When you use the same name in subsequent calls, App Runner creates
incremental revisions of the configuration. Prior to the release of Auto scale
configuration enhancements, the name DefaultConfiguration was reserved. This restriction
is no longer in place. You can now manage DefaultConfiguration the same way you manage your
custom auto scaling configurations. This means you can do the following with the
DefaultConfiguration that App Runner provides: Create new revisions of the
DefaultConfiguration. Delete the revisions of the DefaultConfiguration. Delete the auto
scaling configuration for which the App Runner DefaultConfiguration was created. If you
delete the auto scaling configuration you can create another custom auto scaling
configuration with the same DefaultConfiguration name. The original DefaultConfiguration
resource provided by App Runner remains in your account unless you make changes to it.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxConcurrency"`: The maximum number of concurrent requests that you want an instance
to process. If the number of concurrent requests exceeds this limit, App Runner scales up
your service. Default: 100
- `"MaxSize"`: The maximum number of instances that your service scales up to. At most
MaxSize instances actively serve traffic for your service. Default: 25
- `"MinSize"`: The minimum number of instances that App Runner provisions for your service.
The service always has at least MinSize provisioned instances. Some of them actively serve
traffic. The rest of them (provisioned and inactive instances) are a cost-effective compute
capacity reserve and are ready to be quickly activated. You pay for memory usage of all the
provisioned instances. You pay for CPU usage of only the active subset. App Runner
temporarily doubles the number of provisioned instances during deployments, to maintain the
same capacity for both old and new code. Default: 1
- `"Tags"`: A list of metadata items that you can associate with your auto scaling
configuration resource. A tag is a key-value pair.
"""
function create_auto_scaling_configuration(
AutoScalingConfigurationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"CreateAutoScalingConfiguration",
Dict{String,Any}("AutoScalingConfigurationName" => AutoScalingConfigurationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_auto_scaling_configuration(
AutoScalingConfigurationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateAutoScalingConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingConfigurationName" => AutoScalingConfigurationName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_connection(connection_name, provider_type)
create_connection(connection_name, provider_type, params::Dict{String,<:Any})
Create an App Runner connection resource. App Runner requires a connection resource when
you create App Runner services that access private repositories from certain third-party
providers. You can share a connection across multiple services. A connection resource is
needed to access GitHub and Bitbucket repositories. Both require a user interface approval
process through the App Runner console before you can use the connection.
# Arguments
- `connection_name`: A name for the new connection. It must be unique across all App Runner
connections for the Amazon Web Services account in the Amazon Web Services Region.
- `provider_type`: The source repository provider.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: A list of metadata items that you can associate with your connection resource.
A tag is a key-value pair.
"""
function create_connection(
ConnectionName, ProviderType; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"CreateConnection",
Dict{String,Any}(
"ConnectionName" => ConnectionName, "ProviderType" => ProviderType
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_connection(
ConnectionName,
ProviderType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConnectionName" => ConnectionName, "ProviderType" => ProviderType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_observability_configuration(observability_configuration_name)
create_observability_configuration(observability_configuration_name, params::Dict{String,<:Any})
Create an App Runner observability configuration resource. App Runner requires this
resource when you create or update App Runner services and you want to enable non-default
observability features. You can share an observability configuration across multiple
services. Create multiple revisions of a configuration by calling this action multiple
times using the same ObservabilityConfigurationName. The call returns incremental
ObservabilityConfigurationRevision values. When you create a service and configure an
observability configuration resource, the service uses the latest active revision of the
observability configuration by default. You can optionally configure the service to use a
specific revision. The observability configuration resource is designed to configure
multiple features (currently one feature, tracing). This action takes optional parameters
that describe the configuration of these features (currently one parameter,
TraceConfiguration). If you don't specify a feature parameter, App Runner doesn't enable
the feature.
# Arguments
- `observability_configuration_name`: A name for the observability configuration. When you
use it for the first time in an Amazon Web Services Region, App Runner creates revision
number 1 of this name. When you use the same name in subsequent calls, App Runner creates
incremental revisions of the configuration. The name DefaultConfiguration is reserved. You
can't use it to create a new observability configuration, and you can't create a revision
of it. When you want to use your own observability configuration for your App Runner
service, create a configuration with a different name, and then provide it when you create
or update your service.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: A list of metadata items that you can associate with your observability
configuration resource. A tag is a key-value pair.
- `"TraceConfiguration"`: The configuration of the tracing feature within this
observability configuration. If you don't specify it, App Runner doesn't enable tracing.
"""
function create_observability_configuration(
ObservabilityConfigurationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"CreateObservabilityConfiguration",
Dict{String,Any}(
"ObservabilityConfigurationName" => ObservabilityConfigurationName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_observability_configuration(
ObservabilityConfigurationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateObservabilityConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObservabilityConfigurationName" => ObservabilityConfigurationName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_service(service_name, source_configuration)
create_service(service_name, source_configuration, params::Dict{String,<:Any})
Create an App Runner service. After the service is created, the action also automatically
starts a deployment. This is an asynchronous operation. On a successful call, you can use
the returned OperationId and the ListOperations call to track the operation's progress.
# Arguments
- `service_name`: A name for the App Runner service. It must be unique across all the
running App Runner services in your Amazon Web Services account in the Amazon Web Services
Region.
- `source_configuration`: The source to deploy to the App Runner service. It can be a code
or an image repository.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingConfigurationArn"`: The Amazon Resource Name (ARN) of an App Runner
automatic scaling configuration resource that you want to associate with your service. If
not provided, App Runner associates the latest revision of a default auto scaling
configuration. Specify an ARN with a name and a revision number to associate that revision.
For example:
arn:aws:apprunner:us-east-1:123456789012:autoscalingconfiguration/high-availability/3
Specify just the name to associate the latest revision. For example:
arn:aws:apprunner:us-east-1:123456789012:autoscalingconfiguration/high-availability
- `"EncryptionConfiguration"`: An optional custom encryption key that App Runner uses to
encrypt the copy of your source repository that it maintains and your service logs. By
default, App Runner uses an Amazon Web Services managed key.
- `"HealthCheckConfiguration"`: The settings for the health check that App Runner performs
to monitor the health of the App Runner service.
- `"InstanceConfiguration"`: The runtime configuration of instances (scaling units) of your
service.
- `"NetworkConfiguration"`: Configuration settings related to network traffic of the web
application that the App Runner service runs.
- `"ObservabilityConfiguration"`: The observability configuration of your service.
- `"Tags"`: An optional list of metadata items that you can associate with the App Runner
service resource. A tag is a key-value pair.
"""
function create_service(
ServiceName, SourceConfiguration; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"CreateService",
Dict{String,Any}(
"ServiceName" => ServiceName, "SourceConfiguration" => SourceConfiguration
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_service(
ServiceName,
SourceConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateService",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ServiceName" => ServiceName,
"SourceConfiguration" => SourceConfiguration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_vpc_connector(subnets, vpc_connector_name)
create_vpc_connector(subnets, vpc_connector_name, params::Dict{String,<:Any})
Create an App Runner VPC connector resource. App Runner requires this resource when you
want to associate your App Runner service to a custom Amazon Virtual Private Cloud (Amazon
VPC).
# Arguments
- `subnets`: A list of IDs of subnets that App Runner should use when it associates your
service with a custom Amazon VPC. Specify IDs of subnets of a single Amazon VPC. App Runner
determines the Amazon VPC from the subnets you specify. App Runner currently only
provides support for IPv4.
- `vpc_connector_name`: A name for the VPC connector.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SecurityGroups"`: A list of IDs of security groups that App Runner should use for
access to Amazon Web Services resources under the specified subnets. If not specified, App
Runner uses the default security group of the Amazon VPC. The default security group allows
all outbound traffic.
- `"Tags"`: A list of metadata items that you can associate with your VPC connector
resource. A tag is a key-value pair.
"""
function create_vpc_connector(
Subnets, VpcConnectorName; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"CreateVpcConnector",
Dict{String,Any}("Subnets" => Subnets, "VpcConnectorName" => VpcConnectorName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_vpc_connector(
Subnets,
VpcConnectorName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateVpcConnector",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Subnets" => Subnets, "VpcConnectorName" => VpcConnectorName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_vpc_ingress_connection(ingress_vpc_configuration, service_arn, vpc_ingress_connection_name)
create_vpc_ingress_connection(ingress_vpc_configuration, service_arn, vpc_ingress_connection_name, params::Dict{String,<:Any})
Create an App Runner VPC Ingress Connection resource. App Runner requires this resource
when you want to associate your App Runner service with an Amazon VPC endpoint.
# Arguments
- `ingress_vpc_configuration`: Specifications for the customer’s Amazon VPC and the
related Amazon Web Services PrivateLink VPC endpoint that are used to create the VPC
Ingress Connection resource.
- `service_arn`: The Amazon Resource Name (ARN) for this App Runner service that is used to
create the VPC Ingress Connection resource.
- `vpc_ingress_connection_name`: A name for the VPC Ingress Connection resource. It must be
unique across all the active VPC Ingress Connections in your Amazon Web Services account in
the Amazon Web Services Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: An optional list of metadata items that you can associate with the VPC Ingress
Connection resource. A tag is a key-value pair.
"""
function create_vpc_ingress_connection(
IngressVpcConfiguration,
ServiceArn,
VpcIngressConnectionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateVpcIngressConnection",
Dict{String,Any}(
"IngressVpcConfiguration" => IngressVpcConfiguration,
"ServiceArn" => ServiceArn,
"VpcIngressConnectionName" => VpcIngressConnectionName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_vpc_ingress_connection(
IngressVpcConfiguration,
ServiceArn,
VpcIngressConnectionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"CreateVpcIngressConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IngressVpcConfiguration" => IngressVpcConfiguration,
"ServiceArn" => ServiceArn,
"VpcIngressConnectionName" => VpcIngressConnectionName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_auto_scaling_configuration(auto_scaling_configuration_arn)
delete_auto_scaling_configuration(auto_scaling_configuration_arn, params::Dict{String,<:Any})
Delete an App Runner automatic scaling configuration resource. You can delete a top level
auto scaling configuration, a specific revision of one, or all revisions associated with
the top level configuration. You can't delete the default auto scaling configuration or a
configuration that's used by one or more App Runner services.
# Arguments
- `auto_scaling_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner auto
scaling configuration that you want to delete. The ARN can be a full auto scaling
configuration ARN, or a partial ARN ending with either .../name or .../name/revision . If
a revision isn't specified, the latest active revision is deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DeleteAllRevisions"`: Set to true to delete all of the revisions associated with the
AutoScalingConfigurationArn parameter value. When DeleteAllRevisions is set to true, the
only valid value for the Amazon Resource Name (ARN) is a partial ARN ending with: .../name.
"""
function delete_auto_scaling_configuration(
AutoScalingConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DeleteAutoScalingConfiguration",
Dict{String,Any}("AutoScalingConfigurationArn" => AutoScalingConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_auto_scaling_configuration(
AutoScalingConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteAutoScalingConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingConfigurationArn" => AutoScalingConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_connection(connection_arn)
delete_connection(connection_arn, params::Dict{String,<:Any})
Delete an App Runner connection. You must first ensure that there are no running App Runner
services that use this connection. If there are any, the DeleteConnection action fails.
# Arguments
- `connection_arn`: The Amazon Resource Name (ARN) of the App Runner connection that you
want to delete.
"""
function delete_connection(ConnectionArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"DeleteConnection",
Dict{String,Any}("ConnectionArn" => ConnectionArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_connection(
ConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteConnection",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ConnectionArn" => ConnectionArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_observability_configuration(observability_configuration_arn)
delete_observability_configuration(observability_configuration_arn, params::Dict{String,<:Any})
Delete an App Runner observability configuration resource. You can delete a specific
revision or the latest active revision. You can't delete a configuration that's used by one
or more App Runner services.
# Arguments
- `observability_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner
observability configuration that you want to delete. The ARN can be a full observability
configuration ARN, or a partial ARN ending with either .../name or .../name/revision . If
a revision isn't specified, the latest active revision is deleted.
"""
function delete_observability_configuration(
ObservabilityConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DeleteObservabilityConfiguration",
Dict{String,Any}("ObservabilityConfigurationArn" => ObservabilityConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_observability_configuration(
ObservabilityConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteObservabilityConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObservabilityConfigurationArn" => ObservabilityConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_service(service_arn)
delete_service(service_arn, params::Dict{String,<:Any})
Delete an App Runner service. This is an asynchronous operation. On a successful call, you
can use the returned OperationId and the ListOperations call to track the operation's
progress. Make sure that you don't have any active VPCIngressConnections associated with
the service you want to delete.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
delete.
"""
function delete_service(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"DeleteService",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_service(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteService",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_vpc_connector(vpc_connector_arn)
delete_vpc_connector(vpc_connector_arn, params::Dict{String,<:Any})
Delete an App Runner VPC connector resource. You can't delete a connector that's used by
one or more App Runner services.
# Arguments
- `vpc_connector_arn`: The Amazon Resource Name (ARN) of the App Runner VPC connector that
you want to delete. The ARN must be a full VPC connector ARN.
"""
function delete_vpc_connector(
VpcConnectorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DeleteVpcConnector",
Dict{String,Any}("VpcConnectorArn" => VpcConnectorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_vpc_connector(
VpcConnectorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteVpcConnector",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("VpcConnectorArn" => VpcConnectorArn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_vpc_ingress_connection(vpc_ingress_connection_arn)
delete_vpc_ingress_connection(vpc_ingress_connection_arn, params::Dict{String,<:Any})
Delete an App Runner VPC Ingress Connection resource that's associated with an App Runner
service. The VPC Ingress Connection must be in one of the following states to be deleted:
AVAILABLE FAILED_CREATION FAILED_UPDATE FAILED_DELETION
# Arguments
- `vpc_ingress_connection_arn`: The Amazon Resource Name (ARN) of the App Runner VPC
Ingress Connection that you want to delete.
"""
function delete_vpc_ingress_connection(
VpcIngressConnectionArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DeleteVpcIngressConnection",
Dict{String,Any}("VpcIngressConnectionArn" => VpcIngressConnectionArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_vpc_ingress_connection(
VpcIngressConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DeleteVpcIngressConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("VpcIngressConnectionArn" => VpcIngressConnectionArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_auto_scaling_configuration(auto_scaling_configuration_arn)
describe_auto_scaling_configuration(auto_scaling_configuration_arn, params::Dict{String,<:Any})
Return a full description of an App Runner automatic scaling configuration resource.
# Arguments
- `auto_scaling_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner auto
scaling configuration that you want a description for. The ARN can be a full auto scaling
configuration ARN, or a partial ARN ending with either .../name or .../name/revision . If
a revision isn't specified, the latest active revision is described.
"""
function describe_auto_scaling_configuration(
AutoScalingConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DescribeAutoScalingConfiguration",
Dict{String,Any}("AutoScalingConfigurationArn" => AutoScalingConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_auto_scaling_configuration(
AutoScalingConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeAutoScalingConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingConfigurationArn" => AutoScalingConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_custom_domains(service_arn)
describe_custom_domains(service_arn, params::Dict{String,<:Any})
Return a description of custom domain names that are associated with an App Runner service.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want
associated custom domain names to be described for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results that each response (result page) can
include. It's used for a paginated request. If you don't specify MaxResults, the request
retrieves all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones that are specified in the initial request. If you don't specify NextToken, the
request retrieves the first result page.
"""
function describe_custom_domains(
ServiceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DescribeCustomDomains",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_custom_domains(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeCustomDomains",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_observability_configuration(observability_configuration_arn)
describe_observability_configuration(observability_configuration_arn, params::Dict{String,<:Any})
Return a full description of an App Runner observability configuration resource.
# Arguments
- `observability_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner
observability configuration that you want a description for. The ARN can be a full
observability configuration ARN, or a partial ARN ending with either .../name or
.../name/revision . If a revision isn't specified, the latest active revision is described.
"""
function describe_observability_configuration(
ObservabilityConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DescribeObservabilityConfiguration",
Dict{String,Any}("ObservabilityConfigurationArn" => ObservabilityConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_observability_configuration(
ObservabilityConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeObservabilityConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObservabilityConfigurationArn" => ObservabilityConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_service(service_arn)
describe_service(service_arn, params::Dict{String,<:Any})
Return a full description of an App Runner service.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want a
description for.
"""
function describe_service(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"DescribeService",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_service(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeService",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_vpc_connector(vpc_connector_arn)
describe_vpc_connector(vpc_connector_arn, params::Dict{String,<:Any})
Return a description of an App Runner VPC connector resource.
# Arguments
- `vpc_connector_arn`: The Amazon Resource Name (ARN) of the App Runner VPC connector that
you want a description for. The ARN must be a full VPC connector ARN.
"""
function describe_vpc_connector(
VpcConnectorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DescribeVpcConnector",
Dict{String,Any}("VpcConnectorArn" => VpcConnectorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_vpc_connector(
VpcConnectorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeVpcConnector",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("VpcConnectorArn" => VpcConnectorArn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_vpc_ingress_connection(vpc_ingress_connection_arn)
describe_vpc_ingress_connection(vpc_ingress_connection_arn, params::Dict{String,<:Any})
Return a full description of an App Runner VPC Ingress Connection resource.
# Arguments
- `vpc_ingress_connection_arn`: The Amazon Resource Name (ARN) of the App Runner VPC
Ingress Connection that you want a description for.
"""
function describe_vpc_ingress_connection(
VpcIngressConnectionArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DescribeVpcIngressConnection",
Dict{String,Any}("VpcIngressConnectionArn" => VpcIngressConnectionArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_vpc_ingress_connection(
VpcIngressConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DescribeVpcIngressConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("VpcIngressConnectionArn" => VpcIngressConnectionArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_custom_domain(domain_name, service_arn)
disassociate_custom_domain(domain_name, service_arn, params::Dict{String,<:Any})
Disassociate a custom domain name from an App Runner service. Certificates tracking domain
validity are associated with a custom domain and are stored in AWS Certificate Manager
(ACM). These certificates aren't deleted as part of this action. App Runner delays
certificate deletion for 30 days after a domain is disassociated from your service.
# Arguments
- `domain_name`: The domain name that you want to disassociate from the App Runner service.
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
disassociate a custom domain name from.
"""
function disassociate_custom_domain(
DomainName, ServiceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"DisassociateCustomDomain",
Dict{String,Any}("DomainName" => DomainName, "ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_custom_domain(
DomainName,
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"DisassociateCustomDomain",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "ServiceArn" => ServiceArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_auto_scaling_configurations()
list_auto_scaling_configurations(params::Dict{String,<:Any})
Returns a list of active App Runner automatic scaling configurations in your Amazon Web
Services account. You can query the revisions for a specific configuration name or the
revisions for all active configurations in your account. You can optionally query only the
latest revision of each requested name. To retrieve a full description of a particular
configuration revision, call and provide one of the ARNs returned by
ListAutoScalingConfigurations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingConfigurationName"`: The name of the App Runner auto scaling configuration
that you want to list. If specified, App Runner lists revisions that share this name. If
not specified, App Runner returns revisions of all active configurations.
- `"LatestOnly"`: Set to true to list only the latest revision for each requested
configuration name. Set to false to list all revisions for each requested configuration
name. Default: true
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones that are specified in the initial request. If you don't specify NextToken, the
request retrieves the first result page.
"""
function list_auto_scaling_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListAutoScalingConfigurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_auto_scaling_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListAutoScalingConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_connections()
list_connections(params::Dict{String,<:Any})
Returns a list of App Runner connections that are associated with your Amazon Web Services
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConnectionName"`: If specified, only this connection is returned. If not specified, the
result isn't filtered by name.
- `"MaxResults"`: The maximum number of results to include in each response (result page).
Used for a paginated request. If you don't specify MaxResults, the request retrieves all
available results in a single response.
- `"NextToken"`: A token from a previous result page. Used for a paginated request. The
request retrieves the next result page. All other parameter values must be identical to the
ones specified in the initial request. If you don't specify NextToken, the request
retrieves the first result page.
"""
function list_connections(; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"ListConnections"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_connections(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListConnections", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_observability_configurations()
list_observability_configurations(params::Dict{String,<:Any})
Returns a list of active App Runner observability configurations in your Amazon Web
Services account. You can query the revisions for a specific configuration name or the
revisions for all active configurations in your account. You can optionally query only the
latest revision of each requested name. To retrieve a full description of a particular
configuration revision, call and provide one of the ARNs returned by
ListObservabilityConfigurations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LatestOnly"`: Set to true to list only the latest revision for each requested
configuration name. Set to false to list all revisions for each requested configuration
name. Default: true
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones that are specified in the initial request. If you don't specify NextToken, the
request retrieves the first result page.
- `"ObservabilityConfigurationName"`: The name of the App Runner observability
configuration that you want to list. If specified, App Runner lists revisions that share
this name. If not specified, App Runner returns revisions of all active configurations.
"""
function list_observability_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListObservabilityConfigurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_observability_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListObservabilityConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_operations(service_arn)
list_operations(service_arn, params::Dict{String,<:Any})
Return a list of operations that occurred on an App Runner service. The resulting list of
OperationSummary objects is sorted in reverse chronological order. The first object on the
list represents the last started operation.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want a
list of operations for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones specified in the initial request. If you don't specify NextToken, the request
retrieves the first result page.
"""
function list_operations(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"ListOperations",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_operations(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"ListOperations",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_services()
list_services(params::Dict{String,<:Any})
Returns a list of running App Runner services in your Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. Used for a paginated request. The
request retrieves the next result page. All other parameter values must be identical to the
ones specified in the initial request. If you don't specify NextToken, the request
retrieves the first result page.
"""
function list_services(; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner("ListServices"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_services(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListServices", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_services_for_auto_scaling_configuration(auto_scaling_configuration_arn)
list_services_for_auto_scaling_configuration(auto_scaling_configuration_arn, params::Dict{String,<:Any})
Returns a list of the associated App Runner services using an auto scaling configuration.
# Arguments
- `auto_scaling_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner auto
scaling configuration that you want to list the services for. The ARN can be a full auto
scaling configuration ARN, or a partial ARN ending with either .../name or
.../name/revision . If a revision isn't specified, the latest active revision is used.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones specified in the initial request. If you don't specify NextToken, the request
retrieves the first result page.
"""
function list_services_for_auto_scaling_configuration(
AutoScalingConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListServicesForAutoScalingConfiguration",
Dict{String,Any}("AutoScalingConfigurationArn" => AutoScalingConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_services_for_auto_scaling_configuration(
AutoScalingConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"ListServicesForAutoScalingConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingConfigurationArn" => AutoScalingConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
List tags that are associated with for an App Runner resource. The response contains a list
of tag key-value pairs.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that a tag list is
requested for. It must be the ARN of an App Runner resource.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_vpc_connectors()
list_vpc_connectors(params::Dict{String,<:Any})
Returns a list of App Runner VPC connectors in your Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones that are specified in the initial request. If you don't specify NextToken, the
request retrieves the first result page.
"""
function list_vpc_connectors(; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"ListVpcConnectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_vpc_connectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListVpcConnectors", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_vpc_ingress_connections()
list_vpc_ingress_connections(params::Dict{String,<:Any})
Return a list of App Runner VPC Ingress Connections in your Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filter"`: The VPC Ingress Connections to be listed based on either the Service Arn or
Vpc Endpoint Id, or both.
- `"MaxResults"`: The maximum number of results to include in each response (result page).
It's used for a paginated request. If you don't specify MaxResults, the request retrieves
all available results in a single response.
- `"NextToken"`: A token from a previous result page. It's used for a paginated request.
The request retrieves the next result page. All other parameter values must be identical to
the ones that are specified in the initial request. If you don't specify NextToken, the
request retrieves the first result page.
"""
function list_vpc_ingress_connections(; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"ListVpcIngressConnections"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_vpc_ingress_connections(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"ListVpcIngressConnections",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
pause_service(service_arn)
pause_service(service_arn, params::Dict{String,<:Any})
Pause an active App Runner service. App Runner reduces compute capacity for the service to
zero and loses state (for example, ephemeral storage is removed). This is an asynchronous
operation. On a successful call, you can use the returned OperationId and the
ListOperations call to track the operation's progress.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
pause.
"""
function pause_service(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"PauseService",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function pause_service(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"PauseService",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
resume_service(service_arn)
resume_service(service_arn, params::Dict{String,<:Any})
Resume an active App Runner service. App Runner provisions compute capacity for the
service. This is an asynchronous operation. On a successful call, you can use the returned
OperationId and the ListOperations call to track the operation's progress.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
resume.
"""
function resume_service(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"ResumeService",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function resume_service(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"ResumeService",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_deployment(service_arn)
start_deployment(service_arn, params::Dict{String,<:Any})
Initiate a manual deployment of the latest commit in a source code repository or the latest
image in a source image repository to an App Runner service. For a source code repository,
App Runner retrieves the commit and builds a Docker image. For a source image repository,
App Runner retrieves the latest Docker image. In both cases, App Runner then deploys the
new image to your service and starts a new container instance. This is an asynchronous
operation. On a successful call, you can use the returned OperationId and the
ListOperations call to track the operation's progress.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
manually deploy to.
"""
function start_deployment(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"StartDeployment",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_deployment(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"StartDeployment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Add tags to, or update the tag values of, an App Runner resource. A tag is a key-value pair.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to update
tags for. It must be the ARN of an App Runner resource.
- `tags`: A list of tag key-value pairs to add or update. If a key is new to the resource,
the tag is added with the provided value. If a key is already associated with the resource,
the value of the tag is updated.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"TagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Remove tags from an App Runner resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to remove
tags from. It must be the ARN of an App Runner resource.
- `tag_keys`: A list of tag keys that you want to remove.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"UntagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_default_auto_scaling_configuration(auto_scaling_configuration_arn)
update_default_auto_scaling_configuration(auto_scaling_configuration_arn, params::Dict{String,<:Any})
Update an auto scaling configuration to be the default. The existing default auto scaling
configuration will be set to non-default automatically.
# Arguments
- `auto_scaling_configuration_arn`: The Amazon Resource Name (ARN) of the App Runner auto
scaling configuration that you want to set as the default. The ARN can be a full auto
scaling configuration ARN, or a partial ARN ending with either .../name or
.../name/revision . If a revision isn't specified, the latest active revision is set as the
default.
"""
function update_default_auto_scaling_configuration(
AutoScalingConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apprunner(
"UpdateDefaultAutoScalingConfiguration",
Dict{String,Any}("AutoScalingConfigurationArn" => AutoScalingConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_default_auto_scaling_configuration(
AutoScalingConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"UpdateDefaultAutoScalingConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingConfigurationArn" => AutoScalingConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_service(service_arn)
update_service(service_arn, params::Dict{String,<:Any})
Update an App Runner service. You can update the source configuration and instance
configuration of the service. You can also update the ARN of the auto scaling configuration
resource that's associated with the service. However, you can't change the name or the
encryption configuration of the service. These can be set only when you create the service.
To update the tags applied to your service, use the separate actions TagResource and
UntagResource. This is an asynchronous operation. On a successful call, you can use the
returned OperationId and the ListOperations call to track the operation's progress.
# Arguments
- `service_arn`: The Amazon Resource Name (ARN) of the App Runner service that you want to
update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingConfigurationArn"`: The Amazon Resource Name (ARN) of an App Runner
automatic scaling configuration resource that you want to associate with the App Runner
service.
- `"HealthCheckConfiguration"`: The settings for the health check that App Runner performs
to monitor the health of the App Runner service.
- `"InstanceConfiguration"`: The runtime configuration to apply to instances (scaling
units) of your service.
- `"NetworkConfiguration"`: Configuration settings related to network traffic of the web
application that the App Runner service runs.
- `"ObservabilityConfiguration"`: The observability configuration of your service.
- `"SourceConfiguration"`: The source configuration to apply to the App Runner service. You
can change the configuration of the code or image repository that the service uses.
However, you can't switch from code to image or the other way around. This means that you
must provide the same structure member of SourceConfiguration that you originally included
when you created the service. Specifically, you can include either CodeRepository or
ImageRepository. To update the source configuration, set the values to members of the
structure that you include.
"""
function update_service(ServiceArn; aws_config::AbstractAWSConfig=global_aws_config())
return apprunner(
"UpdateService",
Dict{String,Any}("ServiceArn" => ServiceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_service(
ServiceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"UpdateService",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ServiceArn" => ServiceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_vpc_ingress_connection(ingress_vpc_configuration, vpc_ingress_connection_arn)
update_vpc_ingress_connection(ingress_vpc_configuration, vpc_ingress_connection_arn, params::Dict{String,<:Any})
Update an existing App Runner VPC Ingress Connection resource. The VPC Ingress Connection
must be in one of the following states to be updated: AVAILABLE FAILED_CREATION
FAILED_UPDATE
# Arguments
- `ingress_vpc_configuration`: Specifications for the customer’s Amazon VPC and the
related Amazon Web Services PrivateLink VPC endpoint that are used to update the VPC
Ingress Connection resource.
- `vpc_ingress_connection_arn`: The Amazon Resource Name (Arn) for the App Runner VPC
Ingress Connection resource that you want to update.
"""
function update_vpc_ingress_connection(
IngressVpcConfiguration,
VpcIngressConnectionArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"UpdateVpcIngressConnection",
Dict{String,Any}(
"IngressVpcConfiguration" => IngressVpcConfiguration,
"VpcIngressConnectionArn" => VpcIngressConnectionArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_vpc_ingress_connection(
IngressVpcConfiguration,
VpcIngressConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apprunner(
"UpdateVpcIngressConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IngressVpcConfiguration" => IngressVpcConfiguration,
"VpcIngressConnectionArn" => VpcIngressConnectionArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 122678 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appstream
using AWS.Compat
using AWS.UUIDs
"""
associate_app_block_builder_app_block(app_block_arn, app_block_builder_name)
associate_app_block_builder_app_block(app_block_arn, app_block_builder_name, params::Dict{String,<:Any})
Associates the specified app block builder with the specified app block.
# Arguments
- `app_block_arn`: The ARN of the app block.
- `app_block_builder_name`: The name of the app block builder.
"""
function associate_app_block_builder_app_block(
AppBlockArn, AppBlockBuilderName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"AssociateAppBlockBuilderAppBlock",
Dict{String,Any}(
"AppBlockArn" => AppBlockArn, "AppBlockBuilderName" => AppBlockBuilderName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_app_block_builder_app_block(
AppBlockArn,
AppBlockBuilderName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"AssociateAppBlockBuilderAppBlock",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppBlockArn" => AppBlockArn,
"AppBlockBuilderName" => AppBlockBuilderName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_application_fleet(application_arn, fleet_name)
associate_application_fleet(application_arn, fleet_name, params::Dict{String,<:Any})
Associates the specified application with the specified fleet. This is only supported for
Elastic fleets.
# Arguments
- `application_arn`: The ARN of the application.
- `fleet_name`: The name of the fleet.
"""
function associate_application_fleet(
ApplicationArn, FleetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"AssociateApplicationFleet",
Dict{String,Any}("ApplicationArn" => ApplicationArn, "FleetName" => FleetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_application_fleet(
ApplicationArn,
FleetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"AssociateApplicationFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationArn" => ApplicationArn, "FleetName" => FleetName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_application_to_entitlement(application_identifier, entitlement_name, stack_name)
associate_application_to_entitlement(application_identifier, entitlement_name, stack_name, params::Dict{String,<:Any})
Associates an application to entitle.
# Arguments
- `application_identifier`: The identifier of the application.
- `entitlement_name`: The name of the entitlement.
- `stack_name`: The name of the stack.
"""
function associate_application_to_entitlement(
ApplicationIdentifier,
EntitlementName,
StackName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"AssociateApplicationToEntitlement",
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"EntitlementName" => EntitlementName,
"StackName" => StackName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_application_to_entitlement(
ApplicationIdentifier,
EntitlementName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"AssociateApplicationToEntitlement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"EntitlementName" => EntitlementName,
"StackName" => StackName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_fleet(fleet_name, stack_name)
associate_fleet(fleet_name, stack_name, params::Dict{String,<:Any})
Associates the specified fleet with the specified stack.
# Arguments
- `fleet_name`: The name of the fleet.
- `stack_name`: The name of the stack.
"""
function associate_fleet(
FleetName, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"AssociateFleet",
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_fleet(
FleetName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"AssociateFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_associate_user_stack(user_stack_associations)
batch_associate_user_stack(user_stack_associations, params::Dict{String,<:Any})
Associates the specified users with the specified stacks. Users in a user pool cannot be
assigned to stacks with fleets that are joined to an Active Directory domain.
# Arguments
- `user_stack_associations`: The list of UserStackAssociation objects.
"""
function batch_associate_user_stack(
UserStackAssociations; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"BatchAssociateUserStack",
Dict{String,Any}("UserStackAssociations" => UserStackAssociations);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_associate_user_stack(
UserStackAssociations,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"BatchAssociateUserStack",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("UserStackAssociations" => UserStackAssociations),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_disassociate_user_stack(user_stack_associations)
batch_disassociate_user_stack(user_stack_associations, params::Dict{String,<:Any})
Disassociates the specified users from the specified stacks.
# Arguments
- `user_stack_associations`: The list of UserStackAssociation objects.
"""
function batch_disassociate_user_stack(
UserStackAssociations; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"BatchDisassociateUserStack",
Dict{String,Any}("UserStackAssociations" => UserStackAssociations);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_disassociate_user_stack(
UserStackAssociations,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"BatchDisassociateUserStack",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("UserStackAssociations" => UserStackAssociations),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
copy_image(destination_image_name, destination_region, source_image_name)
copy_image(destination_image_name, destination_region, source_image_name, params::Dict{String,<:Any})
Copies the image within the same region or to a new region within the same AWS account.
Note that any tags you added to the image will not be copied.
# Arguments
- `destination_image_name`: The name that the image will have when it is copied to the
destination.
- `destination_region`: The destination region to which the image will be copied. This
parameter is required, even if you are copying an image within the same region.
- `source_image_name`: The name of the image to copy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DestinationImageDescription"`: The description that the image will have when it is
copied to the destination.
"""
function copy_image(
DestinationImageName,
DestinationRegion,
SourceImageName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CopyImage",
Dict{String,Any}(
"DestinationImageName" => DestinationImageName,
"DestinationRegion" => DestinationRegion,
"SourceImageName" => SourceImageName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function copy_image(
DestinationImageName,
DestinationRegion,
SourceImageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CopyImage",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DestinationImageName" => DestinationImageName,
"DestinationRegion" => DestinationRegion,
"SourceImageName" => SourceImageName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_block(name, source_s3_location)
create_app_block(name, source_s3_location, params::Dict{String,<:Any})
Creates an app block. App blocks are an Amazon AppStream 2.0 resource that stores the
details about the virtual hard disk in an S3 bucket. It also stores the setup script with
details about how to mount the virtual hard disk. The virtual hard disk includes the
application binaries and other files necessary to launch your applications. Multiple
applications can be assigned to a single app block. This is only supported for Elastic
fleets.
# Arguments
- `name`: The name of the app block.
- `source_s3_location`: The source S3 location of the app block.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the app block.
- `"DisplayName"`: The display name of the app block. This is not displayed to the user.
- `"PackagingType"`: The packaging type of the app block.
- `"PostSetupScriptDetails"`: The post setup script details of the app block. This can only
be provided for the APPSTREAM2 PackagingType.
- `"SetupScriptDetails"`: The setup script details of the app block. This must be provided
for the CUSTOM PackagingType.
- `"Tags"`: The tags assigned to the app block.
"""
function create_app_block(
Name, SourceS3Location; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateAppBlock",
Dict{String,Any}("Name" => Name, "SourceS3Location" => SourceS3Location);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_block(
Name,
SourceS3Location,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateAppBlock",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "SourceS3Location" => SourceS3Location),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_block_builder(instance_type, name, platform, vpc_config)
create_app_block_builder(instance_type, name, platform, vpc_config, params::Dict{String,<:Any})
Creates an app block builder.
# Arguments
- `instance_type`: The instance type to use when launching the app block builder. The
following instance types are available: stream.standard.small stream.standard.medium
stream.standard.large stream.standard.xlarge stream.standard.2xlarge
- `name`: The unique name for the app block builder.
- `platform`: The platform of the app block builder. WINDOWS_SERVER_2019 is the only valid
value.
- `vpc_config`: The VPC configuration for the app block builder. App block builders require
that you specify at least two subnets in different availability zones.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessEndpoints"`: The list of interface VPC endpoint (interface endpoint) objects.
Administrators can connect to the app block builder only through the specified endpoints.
- `"Description"`: The description of the app block builder.
- `"DisplayName"`: The display name of the app block builder.
- `"EnableDefaultInternetAccess"`: Enables or disables default internet access for the app
block builder.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role to apply to the app block
builder. To assume a role, the app block builder calls the AWS Security Token Service (STS)
AssumeRole API operation and passes the ARN of the role to use. The operation creates a new
session with temporary credentials. AppStream 2.0 retrieves the temporary credentials and
creates the appstream_machine_role credential profile on the instance. For more
information, see Using an IAM Role to Grant Permissions to Applications and Scripts Running
on AppStream 2.0 Streaming Instances in the Amazon AppStream 2.0 Administration Guide.
- `"Tags"`: The tags to associate with the app block builder. A tag is a key-value pair,
and the value is optional. For example, Environment=Test. If you do not specify a value,
Environment=. If you do not specify a value, the value is set to an empty string.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following special characters: _ . : / = + - @ For more information, see Tagging Your
Resources in the Amazon AppStream 2.0 Administration Guide.
"""
function create_app_block_builder(
InstanceType,
Name,
Platform,
VpcConfig;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateAppBlockBuilder",
Dict{String,Any}(
"InstanceType" => InstanceType,
"Name" => Name,
"Platform" => Platform,
"VpcConfig" => VpcConfig,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_block_builder(
InstanceType,
Name,
Platform,
VpcConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateAppBlockBuilder",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"InstanceType" => InstanceType,
"Name" => Name,
"Platform" => Platform,
"VpcConfig" => VpcConfig,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_block_builder_streaming_url(app_block_builder_name)
create_app_block_builder_streaming_url(app_block_builder_name, params::Dict{String,<:Any})
Creates a URL to start a create app block builder streaming session.
# Arguments
- `app_block_builder_name`: The name of the app block builder.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Validity"`: The time that the streaming URL will be valid, in seconds. Specify a value
between 1 and 604800 seconds. The default is 3600 seconds.
"""
function create_app_block_builder_streaming_url(
AppBlockBuilderName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateAppBlockBuilderStreamingURL",
Dict{String,Any}("AppBlockBuilderName" => AppBlockBuilderName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_block_builder_streaming_url(
AppBlockBuilderName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateAppBlockBuilderStreamingURL",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AppBlockBuilderName" => AppBlockBuilderName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_application(app_block_arn, icon_s3_location, instance_families, launch_path, name, platforms)
create_application(app_block_arn, icon_s3_location, instance_families, launch_path, name, platforms, params::Dict{String,<:Any})
Creates an application. Applications are an Amazon AppStream 2.0 resource that stores the
details about how to launch applications on Elastic fleet streaming instances. An
application consists of the launch details, icon, and display name. Applications are
associated with an app block that contains the application binaries and other files. The
applications assigned to an Elastic fleet are the applications users can launch. This is
only supported for Elastic fleets.
# Arguments
- `app_block_arn`: The app block ARN to which the application should be associated
- `icon_s3_location`: The location in S3 of the application icon.
- `instance_families`: The instance families the application supports. Valid values are
GENERAL_PURPOSE and GRAPHICS_G4.
- `launch_path`: The launch path of the application.
- `name`: The name of the application. This name is visible to users when display name is
not specified.
- `platforms`: The platforms the application supports. WINDOWS_SERVER_2019 and
AMAZON_LINUX2 are supported for Elastic fleets.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the application.
- `"DisplayName"`: The display name of the application. This name is visible to users in
the application catalog.
- `"LaunchParameters"`: The launch parameters of the application.
- `"Tags"`: The tags assigned to the application.
- `"WorkingDirectory"`: The working directory of the application.
"""
function create_application(
AppBlockArn,
IconS3Location,
InstanceFamilies,
LaunchPath,
Name,
Platforms;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateApplication",
Dict{String,Any}(
"AppBlockArn" => AppBlockArn,
"IconS3Location" => IconS3Location,
"InstanceFamilies" => InstanceFamilies,
"LaunchPath" => LaunchPath,
"Name" => Name,
"Platforms" => Platforms,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_application(
AppBlockArn,
IconS3Location,
InstanceFamilies,
LaunchPath,
Name,
Platforms,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateApplication",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppBlockArn" => AppBlockArn,
"IconS3Location" => IconS3Location,
"InstanceFamilies" => InstanceFamilies,
"LaunchPath" => LaunchPath,
"Name" => Name,
"Platforms" => Platforms,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_directory_config(directory_name, organizational_unit_distinguished_names)
create_directory_config(directory_name, organizational_unit_distinguished_names, params::Dict{String,<:Any})
Creates a Directory Config object in AppStream 2.0. This object includes the configuration
information required to join fleets and image builders to Microsoft Active Directory
domains.
# Arguments
- `directory_name`: The fully qualified name of the directory (for example,
corp.example.com).
- `organizational_unit_distinguished_names`: The distinguished names of the organizational
units for computer accounts.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateBasedAuthProperties"`: The certificate-based authentication properties used
to authenticate SAML 2.0 Identity Provider (IdP) user identities to Active Directory
domain-joined streaming instances. Fallback is turned on by default when certificate-based
authentication is Enabled . Fallback allows users to log in using their AD domain password
if certificate-based authentication is unsuccessful, or to unlock a desktop lock screen.
Enabled_no_directory_login_fallback enables certificate-based authentication, but does not
allow users to log in using their AD domain password. Users will be disconnected to
re-authenticate using certificates.
- `"ServiceAccountCredentials"`: The credentials for the service account used by the fleet
or image builder to connect to the directory.
"""
function create_directory_config(
DirectoryName,
OrganizationalUnitDistinguishedNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateDirectoryConfig",
Dict{String,Any}(
"DirectoryName" => DirectoryName,
"OrganizationalUnitDistinguishedNames" => OrganizationalUnitDistinguishedNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_directory_config(
DirectoryName,
OrganizationalUnitDistinguishedNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateDirectoryConfig",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DirectoryName" => DirectoryName,
"OrganizationalUnitDistinguishedNames" =>
OrganizationalUnitDistinguishedNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_entitlement(app_visibility, attributes, name, stack_name)
create_entitlement(app_visibility, attributes, name, stack_name, params::Dict{String,<:Any})
Creates a new entitlement. Entitlements control access to specific applications within a
stack, based on user attributes. Entitlements apply to SAML 2.0 federated user identities.
Amazon AppStream 2.0 user pool and streaming URL users are entitled to all applications in
a stack. Entitlements don't apply to the desktop stream view application, or to
applications managed by a dynamic app provider using the Dynamic Application Framework.
# Arguments
- `app_visibility`: Specifies whether all or selected apps are entitled.
- `attributes`: The attributes of the entitlement.
- `name`: The name of the entitlement.
- `stack_name`: The name of the stack with which the entitlement is associated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the entitlement.
"""
function create_entitlement(
AppVisibility,
Attributes,
Name,
StackName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateEntitlement",
Dict{String,Any}(
"AppVisibility" => AppVisibility,
"Attributes" => Attributes,
"Name" => Name,
"StackName" => StackName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_entitlement(
AppVisibility,
Attributes,
Name,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateEntitlement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppVisibility" => AppVisibility,
"Attributes" => Attributes,
"Name" => Name,
"StackName" => StackName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_fleet(instance_type, name)
create_fleet(instance_type, name, params::Dict{String,<:Any})
Creates a fleet. A fleet consists of streaming instances that your users access for their
applications and desktops.
# Arguments
- `instance_type`: The instance type to use when launching fleet instances. The following
instance types are available: stream.standard.small stream.standard.medium
stream.standard.large stream.standard.xlarge stream.standard.2xlarge
stream.compute.large stream.compute.xlarge stream.compute.2xlarge
stream.compute.4xlarge stream.compute.8xlarge stream.memory.large
stream.memory.xlarge stream.memory.2xlarge stream.memory.4xlarge
stream.memory.8xlarge stream.memory.z1d.large stream.memory.z1d.xlarge
stream.memory.z1d.2xlarge stream.memory.z1d.3xlarge stream.memory.z1d.6xlarge
stream.memory.z1d.12xlarge stream.graphics-design.large stream.graphics-design.xlarge
stream.graphics-design.2xlarge stream.graphics-design.4xlarge
stream.graphics-desktop.2xlarge stream.graphics.g4dn.xlarge
stream.graphics.g4dn.2xlarge stream.graphics.g4dn.4xlarge stream.graphics.g4dn.8xlarge
stream.graphics.g4dn.12xlarge stream.graphics.g4dn.16xlarge
stream.graphics-pro.4xlarge stream.graphics-pro.8xlarge stream.graphics-pro.16xlarge
The following instance types are available for Elastic fleets: stream.standard.small
stream.standard.medium stream.standard.large stream.standard.xlarge
stream.standard.2xlarge
- `name`: A unique name for the fleet.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ComputeCapacity"`: The desired capacity for the fleet. This is not allowed for Elastic
fleets. For Elastic fleets, specify MaxConcurrentSessions instead.
- `"Description"`: The description to display.
- `"DisconnectTimeoutInSeconds"`: The amount of time that a streaming session remains
active after users disconnect. If users try to reconnect to the streaming session after a
disconnection or network interruption within this time interval, they are connected to
their previous session. Otherwise, they are connected to a new session with a new streaming
instance. Specify a value between 60 and 360000.
- `"DisplayName"`: The fleet name to display.
- `"DomainJoinInfo"`: The name of the directory and organizational unit (OU) to use to join
the fleet to a Microsoft Active Directory domain. This is not allowed for Elastic fleets.
- `"EnableDefaultInternetAccess"`: Enables or disables default internet access for the
fleet.
- `"FleetType"`: The fleet type. ALWAYS_ON Provides users with instant-on access to their
apps. You are charged for all running instances in your fleet, even if no users are
streaming apps. ON_DEMAND Provide users with access to applications after they connect,
which takes one to two minutes. You are charged for instance streaming when users are
connected and a small hourly fee for instances that are not streaming apps.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role to apply to the fleet. To
assume a role, a fleet instance calls the AWS Security Token Service (STS) AssumeRole API
operation and passes the ARN of the role to use. The operation creates a new session with
temporary credentials. AppStream 2.0 retrieves the temporary credentials and creates the
appstream_machine_role credential profile on the instance. For more information, see Using
an IAM Role to Grant Permissions to Applications and Scripts Running on AppStream 2.0
Streaming Instances in the Amazon AppStream 2.0 Administration Guide.
- `"IdleDisconnectTimeoutInSeconds"`: The amount of time that users can be idle (inactive)
before they are disconnected from their streaming session and the
DisconnectTimeoutInSeconds time interval begins. Users are notified before they are
disconnected due to inactivity. If they try to reconnect to the streaming session before
the time interval specified in DisconnectTimeoutInSeconds elapses, they are connected to
their previous session. Users are considered idle when they stop providing keyboard or
mouse input during their streaming session. File uploads and downloads, audio in, audio
out, and pixels changing do not qualify as user activity. If users continue to be idle
after the time interval in IdleDisconnectTimeoutInSeconds elapses, they are disconnected.
To prevent users from being disconnected due to inactivity, specify a value of 0.
Otherwise, specify a value between 60 and 3600. The default value is 0. If you enable this
feature, we recommend that you specify a value that corresponds exactly to a whole number
of minutes (for example, 60, 120, and 180). If you don't do this, the value is rounded to
the nearest minute. For example, if you specify a value of 70, users are disconnected after
1 minute of inactivity. If you specify a value that is at the midpoint between two
different minutes, the value is rounded up. For example, if you specify a value of 90,
users are disconnected after 2 minutes of inactivity.
- `"ImageArn"`: The ARN of the public, private, or shared image to use.
- `"ImageName"`: The name of the image used to create the fleet.
- `"MaxConcurrentSessions"`: The maximum concurrent sessions of the Elastic fleet. This is
required for Elastic fleets, and not allowed for other fleet types.
- `"MaxSessionsPerInstance"`: The maximum number of user sessions on an instance. This only
applies to multi-session fleets.
- `"MaxUserDurationInSeconds"`: The maximum amount of time that a streaming session can
remain active, in seconds. If users are still connected to a streaming instance five
minutes before this limit is reached, they are prompted to save any open documents before
being disconnected. After this time elapses, the instance is terminated and replaced by a
new instance. Specify a value between 600 and 432000.
- `"Platform"`: The fleet platform. WINDOWS_SERVER_2019 and AMAZON_LINUX2 are supported for
Elastic fleets.
- `"SessionScriptS3Location"`: The S3 location of the session scripts configuration zip
file. This only applies to Elastic fleets.
- `"StreamView"`: The AppStream 2.0 view that is displayed to your users when they stream
from the fleet. When APP is specified, only the windows of applications opened by users
display. When DESKTOP is specified, the standard desktop that is provided by the operating
system displays. The default value is APP.
- `"Tags"`: The tags to associate with the fleet. A tag is a key-value pair, and the value
is optional. For example, Environment=Test. If you do not specify a value, Environment=.
If you do not specify a value, the value is set to an empty string. Generally allowed
characters are: letters, numbers, and spaces representable in UTF-8, and the following
special characters: _ . : / = + - @ For more information, see Tagging Your Resources in
the Amazon AppStream 2.0 Administration Guide.
- `"UsbDeviceFilterStrings"`: The USB device filter strings that specify which USB devices
a user can redirect to the fleet streaming session, when using the Windows native client.
This is allowed but not required for Elastic fleets.
- `"VpcConfig"`: The VPC configuration for the fleet. This is required for Elastic fleets,
but not required for other fleet types. Elastic fleets require that you specify at least
two subnets in different availability zones.
"""
function create_fleet(InstanceType, Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"CreateFleet",
Dict{String,Any}("InstanceType" => InstanceType, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_fleet(
InstanceType,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("InstanceType" => InstanceType, "Name" => Name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_image_builder(instance_type, name)
create_image_builder(instance_type, name, params::Dict{String,<:Any})
Creates an image builder. An image builder is a virtual machine that is used to create an
image. The initial state of the builder is PENDING. When it is ready, the state is RUNNING.
# Arguments
- `instance_type`: The instance type to use when launching the image builder. The following
instance types are available: stream.standard.small stream.standard.medium
stream.standard.large stream.compute.large stream.compute.xlarge
stream.compute.2xlarge stream.compute.4xlarge stream.compute.8xlarge
stream.memory.large stream.memory.xlarge stream.memory.2xlarge stream.memory.4xlarge
stream.memory.8xlarge stream.memory.z1d.large stream.memory.z1d.xlarge
stream.memory.z1d.2xlarge stream.memory.z1d.3xlarge stream.memory.z1d.6xlarge
stream.memory.z1d.12xlarge stream.graphics-design.large stream.graphics-design.xlarge
stream.graphics-design.2xlarge stream.graphics-design.4xlarge
stream.graphics-desktop.2xlarge stream.graphics.g4dn.xlarge
stream.graphics.g4dn.2xlarge stream.graphics.g4dn.4xlarge stream.graphics.g4dn.8xlarge
stream.graphics.g4dn.12xlarge stream.graphics.g4dn.16xlarge
stream.graphics-pro.4xlarge stream.graphics-pro.8xlarge stream.graphics-pro.16xlarge
- `name`: A unique name for the image builder.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessEndpoints"`: The list of interface VPC endpoint (interface endpoint) objects.
Administrators can connect to the image builder only through the specified endpoints.
- `"AppstreamAgentVersion"`: The version of the AppStream 2.0 agent to use for this image
builder. To use the latest version of the AppStream 2.0 agent, specify [LATEST].
- `"Description"`: The description to display.
- `"DisplayName"`: The image builder name to display.
- `"DomainJoinInfo"`: The name of the directory and organizational unit (OU) to use to join
the image builder to a Microsoft Active Directory domain.
- `"EnableDefaultInternetAccess"`: Enables or disables default internet access for the
image builder.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role to apply to the image
builder. To assume a role, the image builder calls the AWS Security Token Service (STS)
AssumeRole API operation and passes the ARN of the role to use. The operation creates a new
session with temporary credentials. AppStream 2.0 retrieves the temporary credentials and
creates the appstream_machine_role credential profile on the instance. For more
information, see Using an IAM Role to Grant Permissions to Applications and Scripts Running
on AppStream 2.0 Streaming Instances in the Amazon AppStream 2.0 Administration Guide.
- `"ImageArn"`: The ARN of the public, private, or shared image to use.
- `"ImageName"`: The name of the image used to create the image builder.
- `"Tags"`: The tags to associate with the image builder. A tag is a key-value pair, and
the value is optional. For example, Environment=Test. If you do not specify a value,
Environment=. Generally allowed characters are: letters, numbers, and spaces representable
in UTF-8, and the following special characters: _ . : / = + - @ If you do not specify a
value, the value is set to an empty string. For more information about tags, see Tagging
Your Resources in the Amazon AppStream 2.0 Administration Guide.
- `"VpcConfig"`: The VPC configuration for the image builder. You can specify only one
subnet.
"""
function create_image_builder(
InstanceType, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateImageBuilder",
Dict{String,Any}("InstanceType" => InstanceType, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_image_builder(
InstanceType,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateImageBuilder",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("InstanceType" => InstanceType, "Name" => Name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_image_builder_streaming_url(name)
create_image_builder_streaming_url(name, params::Dict{String,<:Any})
Creates a URL to start an image builder streaming session.
# Arguments
- `name`: The name of the image builder.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Validity"`: The time that the streaming URL will be valid, in seconds. Specify a value
between 1 and 604800 seconds. The default is 3600 seconds.
"""
function create_image_builder_streaming_url(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateImageBuilderStreamingURL",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_image_builder_streaming_url(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateImageBuilderStreamingURL",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stack(name)
create_stack(name, params::Dict{String,<:Any})
Creates a stack to start streaming applications to users. A stack consists of an associated
fleet, user access policies, and storage configurations.
# Arguments
- `name`: The name of the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessEndpoints"`: The list of interface VPC endpoint (interface endpoint) objects.
Users of the stack can connect to AppStream 2.0 only through the specified endpoints.
- `"ApplicationSettings"`: The persistent application settings for users of a stack. When
these settings are enabled, changes that users make to applications and Windows settings
are automatically saved after each session and applied to the next session.
- `"Description"`: The description to display.
- `"DisplayName"`: The stack name to display.
- `"EmbedHostDomains"`: The domains where AppStream 2.0 streaming sessions can be embedded
in an iframe. You must approve the domains that you want to host embedded AppStream 2.0
streaming sessions.
- `"FeedbackURL"`: The URL that users are redirected to after they click the Send Feedback
link. If no URL is specified, no Send Feedback link is displayed.
- `"RedirectURL"`: The URL that users are redirected to after their streaming session ends.
- `"StorageConnectors"`: The storage connectors to enable.
- `"StreamingExperienceSettings"`: The streaming protocol you want your stack to prefer.
This can be UDP or TCP. Currently, UDP is only supported in the Windows native client.
- `"Tags"`: The tags to associate with the stack. A tag is a key-value pair, and the value
is optional. For example, Environment=Test. If you do not specify a value, Environment=.
If you do not specify a value, the value is set to an empty string. Generally allowed
characters are: letters, numbers, and spaces representable in UTF-8, and the following
special characters: _ . : / = + - @ For more information about tags, see Tagging Your
Resources in the Amazon AppStream 2.0 Administration Guide.
- `"UserSettings"`: The actions that are enabled or disabled for users during their
streaming sessions. By default, these actions are enabled.
"""
function create_stack(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"CreateStack",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stack(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateStack",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_streaming_url(fleet_name, stack_name, user_id)
create_streaming_url(fleet_name, stack_name, user_id, params::Dict{String,<:Any})
Creates a temporary URL to start an AppStream 2.0 streaming session for the specified user.
A streaming URL enables application streaming to be tested without user setup.
# Arguments
- `fleet_name`: The name of the fleet.
- `stack_name`: The name of the stack.
- `user_id`: The identifier of the user.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApplicationId"`: The name of the application to launch after the session starts. This
is the name that you specified as Name in the Image Assistant. If your fleet is enabled for
the Desktop stream view, you can also choose to launch directly to the operating system
desktop. To do so, specify Desktop.
- `"SessionContext"`: The session context. For more information, see Session Context in the
Amazon AppStream 2.0 Administration Guide.
- `"Validity"`: The time that the streaming URL will be valid, in seconds. Specify a value
between 1 and 604800 seconds. The default is 60 seconds.
"""
function create_streaming_url(
FleetName, StackName, UserId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateStreamingURL",
Dict{String,Any}(
"FleetName" => FleetName, "StackName" => StackName, "UserId" => UserId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_streaming_url(
FleetName,
StackName,
UserId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateStreamingURL",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FleetName" => FleetName, "StackName" => StackName, "UserId" => UserId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_updated_image(existing_image_name, new_image_name)
create_updated_image(existing_image_name, new_image_name, params::Dict{String,<:Any})
Creates a new image with the latest Windows operating system updates, driver updates, and
AppStream 2.0 agent software. For more information, see the \"Update an Image by Using
Managed AppStream 2.0 Image Updates\" section in Administer Your AppStream 2.0 Images, in
the Amazon AppStream 2.0 Administration Guide.
# Arguments
- `existing_image_name`: The name of the image to update.
- `new_image_name`: The name of the new image. The name must be unique within the AWS
account and Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"dryRun"`: Indicates whether to display the status of image update availability before
AppStream 2.0 initiates the process of creating a new updated image. If this value is set
to true, AppStream 2.0 displays whether image updates are available. If this value is set
to false, AppStream 2.0 initiates the process of creating a new updated image without
displaying whether image updates are available.
- `"newImageDescription"`: The description to display for the new image.
- `"newImageDisplayName"`: The name to display for the new image.
- `"newImageTags"`: The tags to associate with the new image. A tag is a key-value pair,
and the value is optional. For example, Environment=Test. If you do not specify a value,
Environment=. Generally allowed characters are: letters, numbers, and spaces representable
in UTF-8, and the following special characters: _ . : / = + - @ If you do not specify a
value, the value is set to an empty string. For more information about tags, see Tagging
Your Resources in the Amazon AppStream 2.0 Administration Guide.
"""
function create_updated_image(
existingImageName, newImageName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateUpdatedImage",
Dict{String,Any}(
"existingImageName" => existingImageName, "newImageName" => newImageName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_updated_image(
existingImageName,
newImageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateUpdatedImage",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"existingImageName" => existingImageName, "newImageName" => newImageName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_usage_report_subscription()
create_usage_report_subscription(params::Dict{String,<:Any})
Creates a usage report subscription. Usage reports are generated daily.
"""
function create_usage_report_subscription(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateUsageReportSubscription";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_usage_report_subscription(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateUsageReportSubscription",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_user(authentication_type, user_name)
create_user(authentication_type, user_name, params::Dict{String,<:Any})
Creates a new user in the user pool.
# Arguments
- `authentication_type`: The authentication type for the user. You must specify USERPOOL.
- `user_name`: The email address of the user. Users' email addresses are case-sensitive.
During login, if they specify an email address that doesn't use the same capitalization as
the email address specified when their user pool account was created, a \"user does not
exist\" error message displays.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"FirstName"`: The first name, or given name, of the user.
- `"LastName"`: The last name, or surname, of the user.
- `"MessageAction"`: The action to take for the welcome email that is sent to a user after
the user is created in the user pool. If you specify SUPPRESS, no email is sent. If you
specify RESEND, do not specify the first name or last name of the user. If the value is
null, the email is sent. The temporary password in the welcome email is valid for only 7
days. If users don’t set their passwords within 7 days, you must send them a new welcome
email.
"""
function create_user(
AuthenticationType, UserName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"CreateUser",
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_user(
AuthenticationType,
UserName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"CreateUser",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_block(name)
delete_app_block(name, params::Dict{String,<:Any})
Deletes an app block.
# Arguments
- `name`: The name of the app block.
"""
function delete_app_block(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteAppBlock",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_block(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteAppBlock",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_block_builder(name)
delete_app_block_builder(name, params::Dict{String,<:Any})
Deletes an app block builder. An app block builder can only be deleted when it has no
association with an app block.
# Arguments
- `name`: The name of the app block builder.
"""
function delete_app_block_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteAppBlockBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_block_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteAppBlockBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_application(name)
delete_application(name, params::Dict{String,<:Any})
Deletes an application.
# Arguments
- `name`: The name of the application.
"""
function delete_application(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteApplication",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_application(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteApplication",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_directory_config(directory_name)
delete_directory_config(directory_name, params::Dict{String,<:Any})
Deletes the specified Directory Config object from AppStream 2.0. This object includes the
information required to join streaming instances to an Active Directory domain.
# Arguments
- `directory_name`: The name of the directory configuration.
"""
function delete_directory_config(
DirectoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteDirectoryConfig",
Dict{String,Any}("DirectoryName" => DirectoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_directory_config(
DirectoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DeleteDirectoryConfig",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DirectoryName" => DirectoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_entitlement(name, stack_name)
delete_entitlement(name, stack_name, params::Dict{String,<:Any})
Deletes the specified entitlement.
# Arguments
- `name`: The name of the entitlement.
- `stack_name`: The name of the stack with which the entitlement is associated.
"""
function delete_entitlement(
Name, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteEntitlement",
Dict{String,Any}("Name" => Name, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_entitlement(
Name,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DeleteEntitlement",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "StackName" => StackName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_fleet(name)
delete_fleet(name, params::Dict{String,<:Any})
Deletes the specified fleet.
# Arguments
- `name`: The name of the fleet.
"""
function delete_fleet(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteFleet",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_fleet(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteFleet",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_image(name)
delete_image(name, params::Dict{String,<:Any})
Deletes the specified image. You cannot delete an image when it is in use. After you delete
an image, you cannot provision new capacity using the image.
# Arguments
- `name`: The name of the image.
"""
function delete_image(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteImage",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_image(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteImage",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_image_builder(name)
delete_image_builder(name, params::Dict{String,<:Any})
Deletes the specified image builder and releases the capacity.
# Arguments
- `name`: The name of the image builder.
"""
function delete_image_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteImageBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_image_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteImageBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_image_permissions(name, shared_account_id)
delete_image_permissions(name, shared_account_id, params::Dict{String,<:Any})
Deletes permissions for the specified private image. After you delete permissions for an
image, AWS accounts to which you previously granted these permissions can no longer use the
image.
# Arguments
- `name`: The name of the private image.
- `shared_account_id`: The 12-digit identifier of the AWS account for which to delete image
permissions.
"""
function delete_image_permissions(
Name, SharedAccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteImagePermissions",
Dict{String,Any}("Name" => Name, "SharedAccountId" => SharedAccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_image_permissions(
Name,
SharedAccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DeleteImagePermissions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "SharedAccountId" => SharedAccountId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stack(name)
delete_stack(name, params::Dict{String,<:Any})
Deletes the specified stack. After the stack is deleted, the application streaming
environment provided by the stack is no longer available to users. Also, any reservations
made for application streaming sessions for the stack are released.
# Arguments
- `name`: The name of the stack.
"""
function delete_stack(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DeleteStack",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stack(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteStack",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_usage_report_subscription()
delete_usage_report_subscription(params::Dict{String,<:Any})
Disables usage report generation.
"""
function delete_usage_report_subscription(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteUsageReportSubscription";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_usage_report_subscription(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteUsageReportSubscription",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_user(authentication_type, user_name)
delete_user(authentication_type, user_name, params::Dict{String,<:Any})
Deletes a user from the user pool.
# Arguments
- `authentication_type`: The authentication type for the user. You must specify USERPOOL.
- `user_name`: The email address of the user. Users' email addresses are case-sensitive.
"""
function delete_user(
AuthenticationType, UserName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DeleteUser",
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_user(
AuthenticationType,
UserName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DeleteUser",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_block_builder_app_block_associations()
describe_app_block_builder_app_block_associations(params::Dict{String,<:Any})
Retrieves a list that describes one or more app block builder associations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AppBlockArn"`: The ARN of the app block.
- `"AppBlockBuilderName"`: The name of the app block builder.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_app_block_builder_app_block_associations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeAppBlockBuilderAppBlockAssociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_block_builder_app_block_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeAppBlockBuilderAppBlockAssociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_block_builders()
describe_app_block_builders(params::Dict{String,<:Any})
Retrieves a list that describes one or more app block builders.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results. The maximum value is 25.
- `"Names"`: The names of the app block builders.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_app_block_builders(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeAppBlockBuilders"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_app_block_builders(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeAppBlockBuilders",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_blocks()
describe_app_blocks(params::Dict{String,<:Any})
Retrieves a list that describes one or more app blocks.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arns"`: The ARNs of the app blocks.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_app_blocks(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeAppBlocks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_app_blocks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeAppBlocks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_application_fleet_associations()
describe_application_fleet_associations(params::Dict{String,<:Any})
Retrieves a list that describes one or more application fleet associations. Either
ApplicationArn or FleetName must be specified.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApplicationArn"`: The ARN of the application.
- `"FleetName"`: The name of the fleet.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_application_fleet_associations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeApplicationFleetAssociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_application_fleet_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeApplicationFleetAssociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_applications()
describe_applications(params::Dict{String,<:Any})
Retrieves a list that describes one or more applications.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arns"`: The ARNs for the applications.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeApplications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeApplications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_directory_configs()
describe_directory_configs(params::Dict{String,<:Any})
Retrieves a list that describes one or more specified Directory Config objects for
AppStream 2.0, if the names for these objects are provided. Otherwise, all Directory Config
objects in the account are described. These objects include the configuration information
required to join fleets and image builders to Microsoft Active Directory domains. Although
the response syntax in this topic includes the account password, this password is not
returned in the actual response.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DirectoryNames"`: The directory names.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_directory_configs(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeDirectoryConfigs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_directory_configs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeDirectoryConfigs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_entitlements(stack_name)
describe_entitlements(stack_name, params::Dict{String,<:Any})
Retrieves a list that describes one of more entitlements.
# Arguments
- `stack_name`: The name of the stack with which the entitlement is associated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"Name"`: The name of the entitlement.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function describe_entitlements(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeEntitlements",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_entitlements(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DescribeEntitlements",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_fleets()
describe_fleets(params::Dict{String,<:Any})
Retrieves a list that describes one or more specified fleets, if the fleet names are
provided. Otherwise, all fleets in the account are described.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Names"`: The names of the fleets to describe.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_fleets(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeFleets"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_fleets(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeFleets", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_image_builders()
describe_image_builders(params::Dict{String,<:Any})
Retrieves a list that describes one or more specified image builders, if the image builder
names are provided. Otherwise, all image builders in the account are described.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"Names"`: The names of the image builders to describe.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_image_builders(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeImageBuilders"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_image_builders(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeImageBuilders",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_image_permissions(name)
describe_image_permissions(name, params::Dict{String,<:Any})
Retrieves a list that describes the permissions for shared AWS account IDs on a private
image that you own.
# Arguments
- `name`: The name of the private image for which to describe permissions. The image must
be one that you own.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
- `"SharedAwsAccountIds"`: The 12-digit identifier of one or more AWS accounts with which
the image is shared.
"""
function describe_image_permissions(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeImagePermissions",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_image_permissions(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeImagePermissions",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_images()
describe_images(params::Dict{String,<:Any})
Retrieves a list that describes one or more specified images, if the image names or image
ARNs are provided. Otherwise, all images in the account are described.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arns"`: The ARNs of the public, private, and shared images to describe.
- `"MaxResults"`: The maximum size of each page of results.
- `"Names"`: The names of the public or private images to describe.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
- `"Type"`: The type of image (public, private, or shared) to describe.
"""
function describe_images(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeImages"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_images(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeImages", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_sessions(fleet_name, stack_name)
describe_sessions(fleet_name, stack_name, params::Dict{String,<:Any})
Retrieves a list that describes the streaming sessions for a specified stack and fleet. If
a UserId is provided for the stack and fleet, only streaming sessions for that user are
described. If an authentication type is not provided, the default is to authenticate users
using a streaming URL.
# Arguments
- `fleet_name`: The name of the fleet. This value is case-sensitive.
- `stack_name`: The name of the stack. This value is case-sensitive.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AuthenticationType"`: The authentication method. Specify API for a user authenticated
using a streaming URL or SAML for a SAML federated user. The default is to authenticate
users using a streaming URL.
- `"InstanceId"`: The identifier for the instance hosting the session.
- `"Limit"`: The size of each page of results. The default value is 20 and the maximum
value is 50.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
- `"UserId"`: The user identifier (ID). If you specify a user ID, you must also specify the
authentication type.
"""
function describe_sessions(
FleetName, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeSessions",
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_sessions(
FleetName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DescribeSessions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stacks()
describe_stacks(params::Dict{String,<:Any})
Retrieves a list that describes one or more specified stacks, if the stack names are
provided. Otherwise, all stacks in the account are described.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Names"`: The names of the stacks to describe.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_stacks(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"DescribeStacks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_stacks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeStacks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_usage_report_subscriptions()
describe_usage_report_subscriptions(params::Dict{String,<:Any})
Retrieves a list that describes one or more usage report subscriptions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_usage_report_subscriptions(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeUsageReportSubscriptions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_usage_report_subscriptions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeUsageReportSubscriptions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_user_stack_associations()
describe_user_stack_associations(params::Dict{String,<:Any})
Retrieves a list that describes the UserStackAssociation objects. You must specify either
or both of the following: The stack name The user name (email address of the user
associated with the stack) and the authentication type for the user
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AuthenticationType"`: The authentication type for the user who is associated with the
stack. You must specify USERPOOL.
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
- `"StackName"`: The name of the stack that is associated with the user.
- `"UserName"`: The email address of the user who is associated with the stack. Users'
email addresses are case-sensitive.
"""
function describe_user_stack_associations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeUserStackAssociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_user_stack_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeUserStackAssociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_users(authentication_type)
describe_users(authentication_type, params::Dict{String,<:Any})
Retrieves a list that describes one or more specified users in the user pool.
# Arguments
- `authentication_type`: The authentication type for the users in the user pool to
describe. You must specify USERPOOL.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function describe_users(
AuthenticationType; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DescribeUsers",
Dict{String,Any}("AuthenticationType" => AuthenticationType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_users(
AuthenticationType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DescribeUsers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("AuthenticationType" => AuthenticationType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_user(authentication_type, user_name)
disable_user(authentication_type, user_name, params::Dict{String,<:Any})
Disables the specified user in the user pool. Users can't sign in to AppStream 2.0 until
they are re-enabled. This action does not delete the user.
# Arguments
- `authentication_type`: The authentication type for the user. You must specify USERPOOL.
- `user_name`: The email address of the user. Users' email addresses are case-sensitive.
"""
function disable_user(
AuthenticationType, UserName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DisableUser",
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_user(
AuthenticationType,
UserName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisableUser",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_app_block_builder_app_block(app_block_arn, app_block_builder_name)
disassociate_app_block_builder_app_block(app_block_arn, app_block_builder_name, params::Dict{String,<:Any})
Disassociates a specified app block builder from a specified app block.
# Arguments
- `app_block_arn`: The ARN of the app block.
- `app_block_builder_name`: The name of the app block builder.
"""
function disassociate_app_block_builder_app_block(
AppBlockArn, AppBlockBuilderName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DisassociateAppBlockBuilderAppBlock",
Dict{String,Any}(
"AppBlockArn" => AppBlockArn, "AppBlockBuilderName" => AppBlockBuilderName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_app_block_builder_app_block(
AppBlockArn,
AppBlockBuilderName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisassociateAppBlockBuilderAppBlock",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppBlockArn" => AppBlockArn,
"AppBlockBuilderName" => AppBlockBuilderName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_application_fleet(application_arn, fleet_name)
disassociate_application_fleet(application_arn, fleet_name, params::Dict{String,<:Any})
Disassociates the specified application from the fleet.
# Arguments
- `application_arn`: The ARN of the application.
- `fleet_name`: The name of the fleet.
"""
function disassociate_application_fleet(
ApplicationArn, FleetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DisassociateApplicationFleet",
Dict{String,Any}("ApplicationArn" => ApplicationArn, "FleetName" => FleetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_application_fleet(
ApplicationArn,
FleetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisassociateApplicationFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationArn" => ApplicationArn, "FleetName" => FleetName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_application_from_entitlement(application_identifier, entitlement_name, stack_name)
disassociate_application_from_entitlement(application_identifier, entitlement_name, stack_name, params::Dict{String,<:Any})
Deletes the specified application from the specified entitlement.
# Arguments
- `application_identifier`: The identifier of the application to remove from the
entitlement.
- `entitlement_name`: The name of the entitlement.
- `stack_name`: The name of the stack with which the entitlement is associated.
"""
function disassociate_application_from_entitlement(
ApplicationIdentifier,
EntitlementName,
StackName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisassociateApplicationFromEntitlement",
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"EntitlementName" => EntitlementName,
"StackName" => StackName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_application_from_entitlement(
ApplicationIdentifier,
EntitlementName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisassociateApplicationFromEntitlement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationIdentifier" => ApplicationIdentifier,
"EntitlementName" => EntitlementName,
"StackName" => StackName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_fleet(fleet_name, stack_name)
disassociate_fleet(fleet_name, stack_name, params::Dict{String,<:Any})
Disassociates the specified fleet from the specified stack.
# Arguments
- `fleet_name`: The name of the fleet.
- `stack_name`: The name of the stack.
"""
function disassociate_fleet(
FleetName, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"DisassociateFleet",
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_fleet(
FleetName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"DisassociateFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("FleetName" => FleetName, "StackName" => StackName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_user(authentication_type, user_name)
enable_user(authentication_type, user_name, params::Dict{String,<:Any})
Enables a user in the user pool. After being enabled, users can sign in to AppStream 2.0
and open applications from the stacks to which they are assigned.
# Arguments
- `authentication_type`: The authentication type for the user. You must specify USERPOOL.
- `user_name`: The email address of the user. Users' email addresses are case-sensitive.
During login, if they specify an email address that doesn't use the same capitalization as
the email address specified when their user pool account was created, a \"user does not
exist\" error message displays.
"""
function enable_user(
AuthenticationType, UserName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"EnableUser",
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_user(
AuthenticationType,
UserName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"EnableUser",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuthenticationType" => AuthenticationType, "UserName" => UserName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
expire_session(session_id)
expire_session(session_id, params::Dict{String,<:Any})
Immediately stops the specified streaming session.
# Arguments
- `session_id`: The identifier of the streaming session.
"""
function expire_session(SessionId; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"ExpireSession",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function expire_session(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"ExpireSession",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_associated_fleets(stack_name)
list_associated_fleets(stack_name, params::Dict{String,<:Any})
Retrieves the name of the fleet that is associated with the specified stack.
# Arguments
- `stack_name`: The name of the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function list_associated_fleets(
StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"ListAssociatedFleets",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_associated_fleets(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"ListAssociatedFleets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_associated_stacks(fleet_name)
list_associated_stacks(fleet_name, params::Dict{String,<:Any})
Retrieves the name of the stack with which the specified fleet is associated.
# Arguments
- `fleet_name`: The name of the fleet.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The pagination token to use to retrieve the next page of results for this
operation. If this value is null, it retrieves the first page.
"""
function list_associated_stacks(
FleetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"ListAssociatedStacks",
Dict{String,Any}("FleetName" => FleetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_associated_stacks(
FleetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"ListAssociatedStacks",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("FleetName" => FleetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_entitled_applications(entitlement_name, stack_name)
list_entitled_applications(entitlement_name, stack_name, params::Dict{String,<:Any})
Retrieves a list of entitled applications.
# Arguments
- `entitlement_name`: The name of the entitlement.
- `stack_name`: The name of the stack with which the entitlement is associated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum size of each page of results.
- `"NextToken"`: The pagination token used to retrieve the next page of results for this
operation.
"""
function list_entitled_applications(
EntitlementName, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"ListEntitledApplications",
Dict{String,Any}("EntitlementName" => EntitlementName, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_entitled_applications(
EntitlementName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"ListEntitledApplications",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EntitlementName" => EntitlementName, "StackName" => StackName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieves a list of all tags for the specified AppStream 2.0 resource. You can tag
AppStream 2.0 image builders, images, fleets, and stacks. For more information about tags,
see Tagging Your Resources in the Amazon AppStream 2.0 Administration Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_app_block_builder(name)
start_app_block_builder(name, params::Dict{String,<:Any})
Starts an app block builder. An app block builder can only be started when it's associated
with an app block. Starting an app block builder starts a new instance, which is equivalent
to an elastic fleet instance with application builder assistance functionality.
# Arguments
- `name`: The name of the app block builder.
"""
function start_app_block_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StartAppBlockBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_app_block_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StartAppBlockBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_fleet(name)
start_fleet(name, params::Dict{String,<:Any})
Starts the specified fleet.
# Arguments
- `name`: The name of the fleet.
"""
function start_fleet(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StartFleet",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_fleet(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StartFleet",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_image_builder(name)
start_image_builder(name, params::Dict{String,<:Any})
Starts the specified image builder.
# Arguments
- `name`: The name of the image builder.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AppstreamAgentVersion"`: The version of the AppStream 2.0 agent to use for this image
builder. To use the latest version of the AppStream 2.0 agent, specify [LATEST].
"""
function start_image_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StartImageBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_image_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StartImageBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_app_block_builder(name)
stop_app_block_builder(name, params::Dict{String,<:Any})
Stops an app block builder. Stopping an app block builder terminates the instance, and the
instance state is not persisted.
# Arguments
- `name`: The name of the app block builder.
"""
function stop_app_block_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StopAppBlockBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_app_block_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StopAppBlockBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_fleet(name)
stop_fleet(name, params::Dict{String,<:Any})
Stops the specified fleet.
# Arguments
- `name`: The name of the fleet.
"""
function stop_fleet(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StopFleet",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_fleet(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StopFleet",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_image_builder(name)
stop_image_builder(name, params::Dict{String,<:Any})
Stops the specified image builder.
# Arguments
- `name`: The name of the image builder.
"""
function stop_image_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"StopImageBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_image_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"StopImageBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds or overwrites one or more tags for the specified AppStream 2.0 resource. You can tag
AppStream 2.0 image builders, images, fleets, and stacks. Each tag consists of a key and an
optional value. If a resource already has a tag with the same key, this operation updates
its value. To list the current tags for your resources, use ListTagsForResource. To
disassociate tags from your resources, use UntagResource. For more information about tags,
see Tagging Your Resources in the Amazon AppStream 2.0 Administration Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tags`: The tags to associate. A tag is a key-value pair, and the value is optional. For
example, Environment=Test. If you do not specify a value, Environment=. If you do not
specify a value, the value is set to an empty string. Generally allowed characters are:
letters, numbers, and spaces representable in UTF-8, and the following special characters:
_ . : / = + - @
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"TagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Disassociates one or more specified tags from the specified AppStream 2.0 resource. To list
the current tags for your resources, use ListTagsForResource. For more information about
tags, see Tagging Your Resources in the Amazon AppStream 2.0 Administration Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tag_keys`: The tag keys for the tags to disassociate.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UntagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_block_builder(name)
update_app_block_builder(name, params::Dict{String,<:Any})
Updates an app block builder. If the app block builder is in the STARTING or STOPPING
state, you can't update it. If the app block builder is in the RUNNING state, you can only
update the DisplayName and Description. If the app block builder is in the STOPPED state,
you can update any attribute except the Name.
# Arguments
- `name`: The unique name for the app block builder.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessEndpoints"`: The list of interface VPC endpoint (interface endpoint) objects.
Administrators can connect to the app block builder only through the specified endpoints.
- `"AttributesToDelete"`: The attributes to delete from the app block builder.
- `"Description"`: The description of the app block builder.
- `"DisplayName"`: The display name of the app block builder.
- `"EnableDefaultInternetAccess"`: Enables or disables default internet access for the app
block builder.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role to apply to the app block
builder. To assume a role, the app block builder calls the AWS Security Token Service (STS)
AssumeRole API operation and passes the ARN of the role to use. The operation creates a new
session with temporary credentials. AppStream 2.0 retrieves the temporary credentials and
creates the appstream_machine_role credential profile on the instance. For more
information, see Using an IAM Role to Grant Permissions to Applications and Scripts Running
on AppStream 2.0 Streaming Instances in the Amazon AppStream 2.0 Administration Guide.
- `"InstanceType"`: The instance type to use when launching the app block builder. The
following instance types are available: stream.standard.small stream.standard.medium
stream.standard.large stream.standard.xlarge stream.standard.2xlarge
- `"Platform"`: The platform of the app block builder. WINDOWS_SERVER_2019 is the only
valid value.
- `"VpcConfig"`: The VPC configuration for the app block builder. App block builders
require that you specify at least two subnets in different availability zones.
"""
function update_app_block_builder(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"UpdateAppBlockBuilder",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_block_builder(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateAppBlockBuilder",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application(name)
update_application(name, params::Dict{String,<:Any})
Updates the specified application.
# Arguments
- `name`: The name of the application. This name is visible to users when display name is
not specified.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AppBlockArn"`: The ARN of the app block.
- `"AttributesToDelete"`: The attributes to delete for an application.
- `"Description"`: The description of the application.
- `"DisplayName"`: The display name of the application. This name is visible to users in
the application catalog.
- `"IconS3Location"`: The icon S3 location of the application.
- `"LaunchParameters"`: The launch parameters of the application.
- `"LaunchPath"`: The launch path of the application.
- `"WorkingDirectory"`: The working directory of the application.
"""
function update_application(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"UpdateApplication",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_application(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateApplication",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_directory_config(directory_name)
update_directory_config(directory_name, params::Dict{String,<:Any})
Updates the specified Directory Config object in AppStream 2.0. This object includes the
configuration information required to join fleets and image builders to Microsoft Active
Directory domains.
# Arguments
- `directory_name`: The name of the Directory Config object.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateBasedAuthProperties"`: The certificate-based authentication properties used
to authenticate SAML 2.0 Identity Provider (IdP) user identities to Active Directory
domain-joined streaming instances. Fallback is turned on by default when certificate-based
authentication is Enabled . Fallback allows users to log in using their AD domain password
if certificate-based authentication is unsuccessful, or to unlock a desktop lock screen.
Enabled_no_directory_login_fallback enables certificate-based authentication, but does not
allow users to log in using their AD domain password. Users will be disconnected to
re-authenticate using certificates.
- `"OrganizationalUnitDistinguishedNames"`: The distinguished names of the organizational
units for computer accounts.
- `"ServiceAccountCredentials"`: The credentials for the service account used by the fleet
or image builder to connect to the directory.
"""
function update_directory_config(
DirectoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateDirectoryConfig",
Dict{String,Any}("DirectoryName" => DirectoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_directory_config(
DirectoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"UpdateDirectoryConfig",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DirectoryName" => DirectoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_entitlement(name, stack_name)
update_entitlement(name, stack_name, params::Dict{String,<:Any})
Updates the specified entitlement.
# Arguments
- `name`: The name of the entitlement.
- `stack_name`: The name of the stack with which the entitlement is associated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AppVisibility"`: Specifies whether all or only selected apps are entitled.
- `"Attributes"`: The attributes of the entitlement.
- `"Description"`: The description of the entitlement.
"""
function update_entitlement(
Name, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateEntitlement",
Dict{String,Any}("Name" => Name, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_entitlement(
Name,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"UpdateEntitlement",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "StackName" => StackName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_fleet()
update_fleet(params::Dict{String,<:Any})
Updates the specified fleet. If the fleet is in the STOPPED state, you can update any
attribute except the fleet name. If the fleet is in the RUNNING state, you can update the
following based on the fleet type: Always-On and On-Demand fleet types You can update the
DisplayName, ComputeCapacity, ImageARN, ImageName, IdleDisconnectTimeoutInSeconds, and
DisconnectTimeoutInSeconds attributes. Elastic fleet type You can update the DisplayName,
IdleDisconnectTimeoutInSeconds, DisconnectTimeoutInSeconds, MaxConcurrentSessions,
SessionScriptS3Location and UsbDeviceFilterStrings attributes. If the fleet is in the
STARTING or STOPPED state, you can't update it.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AttributesToDelete"`: The fleet attributes to delete.
- `"ComputeCapacity"`: The desired capacity for the fleet. This is not allowed for Elastic
fleets.
- `"DeleteVpcConfig"`: Deletes the VPC association for the specified fleet.
- `"Description"`: The description to display.
- `"DisconnectTimeoutInSeconds"`: The amount of time that a streaming session remains
active after users disconnect. If users try to reconnect to the streaming session after a
disconnection or network interruption within this time interval, they are connected to
their previous session. Otherwise, they are connected to a new session with a new streaming
instance. Specify a value between 60 and 360000.
- `"DisplayName"`: The fleet name to display.
- `"DomainJoinInfo"`: The name of the directory and organizational unit (OU) to use to join
the fleet to a Microsoft Active Directory domain.
- `"EnableDefaultInternetAccess"`: Enables or disables default internet access for the
fleet.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role to apply to the fleet. To
assume a role, a fleet instance calls the AWS Security Token Service (STS) AssumeRole API
operation and passes the ARN of the role to use. The operation creates a new session with
temporary credentials. AppStream 2.0 retrieves the temporary credentials and creates the
appstream_machine_role credential profile on the instance. For more information, see Using
an IAM Role to Grant Permissions to Applications and Scripts Running on AppStream 2.0
Streaming Instances in the Amazon AppStream 2.0 Administration Guide.
- `"IdleDisconnectTimeoutInSeconds"`: The amount of time that users can be idle (inactive)
before they are disconnected from their streaming session and the
DisconnectTimeoutInSeconds time interval begins. Users are notified before they are
disconnected due to inactivity. If users try to reconnect to the streaming session before
the time interval specified in DisconnectTimeoutInSeconds elapses, they are connected to
their previous session. Users are considered idle when they stop providing keyboard or
mouse input during their streaming session. File uploads and downloads, audio in, audio
out, and pixels changing do not qualify as user activity. If users continue to be idle
after the time interval in IdleDisconnectTimeoutInSeconds elapses, they are disconnected.
To prevent users from being disconnected due to inactivity, specify a value of 0.
Otherwise, specify a value between 60 and 3600. The default value is 0. If you enable this
feature, we recommend that you specify a value that corresponds exactly to a whole number
of minutes (for example, 60, 120, and 180). If you don't do this, the value is rounded to
the nearest minute. For example, if you specify a value of 70, users are disconnected after
1 minute of inactivity. If you specify a value that is at the midpoint between two
different minutes, the value is rounded up. For example, if you specify a value of 90,
users are disconnected after 2 minutes of inactivity.
- `"ImageArn"`: The ARN of the public, private, or shared image to use.
- `"ImageName"`: The name of the image used to create the fleet.
- `"InstanceType"`: The instance type to use when launching fleet instances. The following
instance types are available: stream.standard.small stream.standard.medium
stream.standard.large stream.standard.xlarge stream.standard.2xlarge
stream.compute.large stream.compute.xlarge stream.compute.2xlarge
stream.compute.4xlarge stream.compute.8xlarge stream.memory.large
stream.memory.xlarge stream.memory.2xlarge stream.memory.4xlarge
stream.memory.8xlarge stream.memory.z1d.large stream.memory.z1d.xlarge
stream.memory.z1d.2xlarge stream.memory.z1d.3xlarge stream.memory.z1d.6xlarge
stream.memory.z1d.12xlarge stream.graphics-design.large stream.graphics-design.xlarge
stream.graphics-design.2xlarge stream.graphics-design.4xlarge
stream.graphics-desktop.2xlarge stream.graphics.g4dn.xlarge
stream.graphics.g4dn.2xlarge stream.graphics.g4dn.4xlarge stream.graphics.g4dn.8xlarge
stream.graphics.g4dn.12xlarge stream.graphics.g4dn.16xlarge
stream.graphics-pro.4xlarge stream.graphics-pro.8xlarge stream.graphics-pro.16xlarge
The following instance types are available for Elastic fleets: stream.standard.small
stream.standard.medium stream.standard.large stream.standard.xlarge
stream.standard.2xlarge
- `"MaxConcurrentSessions"`: The maximum number of concurrent sessions for a fleet.
- `"MaxSessionsPerInstance"`: The maximum number of user sessions on an instance. This only
applies to multi-session fleets.
- `"MaxUserDurationInSeconds"`: The maximum amount of time that a streaming session can
remain active, in seconds. If users are still connected to a streaming instance five
minutes before this limit is reached, they are prompted to save any open documents before
being disconnected. After this time elapses, the instance is terminated and replaced by a
new instance. Specify a value between 600 and 432000.
- `"Name"`: A unique name for the fleet.
- `"Platform"`: The platform of the fleet. WINDOWS_SERVER_2019 and AMAZON_LINUX2 are
supported for Elastic fleets.
- `"SessionScriptS3Location"`: The S3 location of the session scripts configuration zip
file. This only applies to Elastic fleets.
- `"StreamView"`: The AppStream 2.0 view that is displayed to your users when they stream
from the fleet. When APP is specified, only the windows of applications opened by users
display. When DESKTOP is specified, the standard desktop that is provided by the operating
system displays. The default value is APP.
- `"UsbDeviceFilterStrings"`: The USB device filter strings that specify which USB devices
a user can redirect to the fleet streaming session, when using the Windows native client.
This is allowed but not required for Elastic fleets.
- `"VpcConfig"`: The VPC configuration for the fleet. This is required for Elastic fleets,
but not required for other fleet types. Elastic fleets require that you specify at least
two subnets in different availability zones.
"""
function update_fleet(; aws_config::AbstractAWSConfig=global_aws_config())
return appstream("UpdateFleet"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function update_fleet(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateFleet", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_image_permissions(image_permissions, name, shared_account_id)
update_image_permissions(image_permissions, name, shared_account_id, params::Dict{String,<:Any})
Adds or updates permissions for the specified private image.
# Arguments
- `image_permissions`: The permissions for the image.
- `name`: The name of the private image.
- `shared_account_id`: The 12-digit identifier of the AWS account for which you want add or
update image permissions.
"""
function update_image_permissions(
ImagePermissions,
Name,
SharedAccountId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"UpdateImagePermissions",
Dict{String,Any}(
"ImagePermissions" => ImagePermissions,
"Name" => Name,
"SharedAccountId" => SharedAccountId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_image_permissions(
ImagePermissions,
Name,
SharedAccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appstream(
"UpdateImagePermissions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ImagePermissions" => ImagePermissions,
"Name" => Name,
"SharedAccountId" => SharedAccountId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stack(name)
update_stack(name, params::Dict{String,<:Any})
Updates the specified fields for the specified stack.
# Arguments
- `name`: The name of the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessEndpoints"`: The list of interface VPC endpoint (interface endpoint) objects.
Users of the stack can connect to AppStream 2.0 only through the specified endpoints.
- `"ApplicationSettings"`: The persistent application settings for users of a stack. When
these settings are enabled, changes that users make to applications and Windows settings
are automatically saved after each session and applied to the next session.
- `"AttributesToDelete"`: The stack attributes to delete.
- `"DeleteStorageConnectors"`: Deletes the storage connectors currently enabled for the
stack.
- `"Description"`: The description to display.
- `"DisplayName"`: The stack name to display.
- `"EmbedHostDomains"`: The domains where AppStream 2.0 streaming sessions can be embedded
in an iframe. You must approve the domains that you want to host embedded AppStream 2.0
streaming sessions.
- `"FeedbackURL"`: The URL that users are redirected to after they choose the Send Feedback
link. If no URL is specified, no Send Feedback link is displayed.
- `"RedirectURL"`: The URL that users are redirected to after their streaming session ends.
- `"StorageConnectors"`: The storage connectors to enable.
- `"StreamingExperienceSettings"`: The streaming protocol you want your stack to prefer.
This can be UDP or TCP. Currently, UDP is only supported in the Windows native client.
- `"UserSettings"`: The actions that are enabled or disabled for users during their
streaming sessions. By default, these actions are enabled.
"""
function update_stack(Name; aws_config::AbstractAWSConfig=global_aws_config())
return appstream(
"UpdateStack",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stack(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appstream(
"UpdateStack",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 92410 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: appsync
using AWS.Compat
using AWS.UUIDs
"""
associate_api(api_id, domain_name)
associate_api(api_id, domain_name, params::Dict{String,<:Any})
Maps an endpoint to your custom domain.
# Arguments
- `api_id`: The API ID. Private APIs can not be associated with custom domains.
- `domain_name`: The domain name.
"""
function associate_api(apiId, domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"POST",
"/v1/domainnames/$(domainName)/apiassociation",
Dict{String,Any}("apiId" => apiId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_api(
apiId,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/domainnames/$(domainName)/apiassociation",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("apiId" => apiId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_merged_graphql_api(merged_api_identifier, source_api_identifier)
associate_merged_graphql_api(merged_api_identifier, source_api_identifier, params::Dict{String,<:Any})
Creates an association between a Merged API and source API using the source API's
identifier.
# Arguments
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
- `source_api_identifier`: The identifier of the AppSync Source API. This is generated by
the AppSync service. In most cases, source APIs (especially in your account) only require
the API ID value or ARN of the source API. However, source APIs from other accounts
(cross-account use cases) strictly require the full resource ARN of the source API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description field.
- `"sourceApiAssociationConfig"`: The SourceApiAssociationConfig object data.
"""
function associate_merged_graphql_api(
mergedApiIdentifier,
sourceApiIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/sourceApis/$(sourceApiIdentifier)/mergedApiAssociations",
Dict{String,Any}("mergedApiIdentifier" => mergedApiIdentifier);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_merged_graphql_api(
mergedApiIdentifier,
sourceApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/sourceApis/$(sourceApiIdentifier)/mergedApiAssociations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("mergedApiIdentifier" => mergedApiIdentifier),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_source_graphql_api(merged_api_identifier, source_api_identifier)
associate_source_graphql_api(merged_api_identifier, source_api_identifier, params::Dict{String,<:Any})
Creates an association between a Merged API and source API using the Merged API's
identifier.
# Arguments
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
- `source_api_identifier`: The identifier of the AppSync Source API. This is generated by
the AppSync service. In most cases, source APIs (especially in your account) only require
the API ID value or ARN of the source API. However, source APIs from other accounts
(cross-account use cases) strictly require the full resource ARN of the source API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description field.
- `"sourceApiAssociationConfig"`: The SourceApiAssociationConfig object data.
"""
function associate_source_graphql_api(
mergedApiIdentifier,
sourceApiIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations",
Dict{String,Any}("sourceApiIdentifier" => sourceApiIdentifier);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_source_graphql_api(
mergedApiIdentifier,
sourceApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("sourceApiIdentifier" => sourceApiIdentifier),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_api_cache(api_caching_behavior, api_id, ttl, type)
create_api_cache(api_caching_behavior, api_id, ttl, type, params::Dict{String,<:Any})
Creates a cache for the GraphQL API.
# Arguments
- `api_caching_behavior`: Caching behavior. FULL_REQUEST_CACHING: All requests are fully
cached. PER_RESOLVER_CACHING: Individual resolvers that you specify are cached.
- `api_id`: The GraphQL API ID.
- `ttl`: TTL in seconds for cache entries. Valid values are 1–3,600 seconds.
- `type`: The cache instance type. Valid values are SMALL MEDIUM LARGE
XLARGE LARGE_2X LARGE_4X LARGE_8X (not available in all regions) LARGE_12X
Historically, instance types were identified by an EC2-style value. As of July 2020, this
is deprecated, and the generic identifiers above should be used. The following legacy
instance types are available, but their use is discouraged: T2_SMALL: A t2.small
instance type. T2_MEDIUM: A t2.medium instance type. R4_LARGE: A r4.large instance
type. R4_XLARGE: A r4.xlarge instance type. R4_2XLARGE: A r4.2xlarge instance type.
R4_4XLARGE: A r4.4xlarge instance type. R4_8XLARGE: A r4.8xlarge instance type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"atRestEncryptionEnabled"`: At-rest encryption flag for cache. You cannot update this
setting after creation.
- `"healthMetricsConfig"`: Controls how cache health metrics will be emitted to CloudWatch.
Cache health metrics include: NetworkBandwidthOutAllowanceExceeded: The network packets
dropped because the throughput exceeded the aggregated bandwidth limit. This is useful for
diagnosing bottlenecks in a cache configuration. EngineCPUUtilization: The CPU
utilization (percentage) allocated to the Redis process. This is useful for diagnosing
bottlenecks in a cache configuration. Metrics will be recorded by API ID. You can set the
value to ENABLED or DISABLED.
- `"transitEncryptionEnabled"`: Transit encryption flag when connecting to cache. You
cannot update this setting after creation.
"""
function create_api_cache(
apiCachingBehavior, apiId, ttl, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/ApiCaches",
Dict{String,Any}(
"apiCachingBehavior" => apiCachingBehavior, "ttl" => ttl, "type" => type
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_api_cache(
apiCachingBehavior,
apiId,
ttl,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/ApiCaches",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"apiCachingBehavior" => apiCachingBehavior, "ttl" => ttl, "type" => type
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_api_key(api_id)
create_api_key(api_id, params::Dict{String,<:Any})
Creates a unique key that you can distribute to clients who invoke your API.
# Arguments
- `api_id`: The ID for your GraphQL API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the purpose of the API key.
- `"expires"`: From the creation time, the time after which the API key expires. The date
is represented as seconds since the epoch, rounded down to the nearest hour. The default
value for this parameter is 7 days from creation time. For more information, see .
"""
function create_api_key(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"POST",
"/v1/apis/$(apiId)/apikeys";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_api_key(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/apikeys",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_data_source(api_id, name, type)
create_data_source(api_id, name, type, params::Dict{String,<:Any})
Creates a DataSource object.
# Arguments
- `api_id`: The API ID for the GraphQL API for the DataSource.
- `name`: A user-supplied name for the DataSource.
- `type`: The type of the DataSource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the DataSource.
- `"dynamodbConfig"`: Amazon DynamoDB settings.
- `"elasticsearchConfig"`: Amazon OpenSearch Service settings. As of September 2021, Amazon
Elasticsearch service is Amazon OpenSearch Service. This configuration is deprecated. For
new data sources, use CreateDataSourceRequestopenSearchServiceConfig to create an
OpenSearch data source.
- `"eventBridgeConfig"`: Amazon EventBridge settings.
- `"httpConfig"`: HTTP endpoint settings.
- `"lambdaConfig"`: Lambda settings.
- `"metricsConfig"`: Enables or disables enhanced data source metrics for specified data
sources. Note that metricsConfig won't be used unless the dataSourceLevelMetricsBehavior
value is set to PER_DATA_SOURCE_METRICS. If the dataSourceLevelMetricsBehavior is set to
FULL_REQUEST_DATA_SOURCE_METRICS instead, metricsConfig will be ignored. However, you can
still set its value. metricsConfig can be ENABLED or DISABLED.
- `"openSearchServiceConfig"`: Amazon OpenSearch Service settings.
- `"relationalDatabaseConfig"`: Relational database settings.
- `"serviceRoleArn"`: The Identity and Access Management (IAM) service role Amazon Resource
Name (ARN) for the data source. The system assumes this role when accessing the data source.
"""
function create_data_source(
apiId, name, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/datasources",
Dict{String,Any}("name" => name, "type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_data_source(
apiId,
name,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/datasources",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("name" => name, "type" => type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain_name(certificate_arn, domain_name)
create_domain_name(certificate_arn, domain_name, params::Dict{String,<:Any})
Creates a custom DomainName object.
# Arguments
- `certificate_arn`: The Amazon Resource Name (ARN) of the certificate. This can be an
Certificate Manager (ACM) certificate or an Identity and Access Management (IAM) server
certificate.
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the DomainName.
"""
function create_domain_name(
certificateArn, domainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/domainnames",
Dict{String,Any}("certificateArn" => certificateArn, "domainName" => domainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain_name(
certificateArn,
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/domainnames",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"certificateArn" => certificateArn, "domainName" => domainName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_function(api_id, data_source_name, name)
create_function(api_id, data_source_name, name, params::Dict{String,<:Any})
Creates a Function object. A function is a reusable entity. You can use multiple functions
to compose the resolver logic.
# Arguments
- `api_id`: The GraphQL API ID.
- `data_source_name`: The Function DataSource name.
- `name`: The Function name. The function name does not have to be unique.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"code"`: The function code that contains the request and response functions. When code
is used, the runtime is required. The runtime value must be APPSYNC_JS.
- `"description"`: The Function description.
- `"functionVersion"`: The version of the request mapping template. Currently, the
supported value is 2018-05-29. Note that when using VTL and mapping templates, the
functionVersion is required.
- `"maxBatchSize"`: The maximum batching size for a resolver.
- `"requestMappingTemplate"`: The Function request mapping template. Functions support only
the 2018-05-29 version of the request mapping template.
- `"responseMappingTemplate"`: The Function response mapping template.
- `"runtime"`:
- `"syncConfig"`:
"""
function create_function(
apiId, dataSourceName, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/functions",
Dict{String,Any}("dataSourceName" => dataSourceName, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_function(
apiId,
dataSourceName,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/functions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("dataSourceName" => dataSourceName, "name" => name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_graphql_api(authentication_type, name)
create_graphql_api(authentication_type, name, params::Dict{String,<:Any})
Creates a GraphqlApi object.
# Arguments
- `authentication_type`: The authentication type: API key, Identity and Access Management
(IAM), OpenID Connect (OIDC), Amazon Cognito user pools, or Lambda.
- `name`: A user-supplied name for the GraphqlApi.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalAuthenticationProviders"`: A list of additional authentication providers for
the GraphqlApi API.
- `"apiType"`: The value that indicates whether the GraphQL API is a standard API (GRAPHQL)
or merged API (MERGED).
- `"enhancedMetricsConfig"`: The enhancedMetricsConfig object.
- `"introspectionConfig"`: Sets the value of the GraphQL API to enable (ENABLED) or disable
(DISABLED) introspection. If no value is provided, the introspection configuration will be
set to ENABLED by default. This field will produce an error if the operation attempts to
use the introspection feature while this field is disabled. For more information about
introspection, see GraphQL introspection.
- `"lambdaAuthorizerConfig"`: Configuration for Lambda function authorization.
- `"logConfig"`: The Amazon CloudWatch Logs configuration.
- `"mergedApiExecutionRoleArn"`: The Identity and Access Management service role ARN for a
merged API. The AppSync service assumes this role on behalf of the Merged API to validate
access to source APIs at runtime and to prompt the AUTO_MERGE to update the merged API
endpoint with the source API changes automatically.
- `"openIDConnectConfig"`: The OIDC configuration.
- `"ownerContact"`: The owner contact information for an API resource. This field accepts
any string input with a length of 0 - 256 characters.
- `"queryDepthLimit"`: The maximum depth a query can have in a single request. Depth refers
to the amount of nested levels allowed in the body of query. The default value is 0 (or
unspecified), which indicates there's no depth limit. If you set a limit, it can be between
1 and 75 nested levels. This field will produce a limit error if the operation falls out of
bounds. Note that fields can still be set to nullable or non-nullable. If a non-nullable
field produces an error, the error will be thrown upwards to the first nullable field
available.
- `"resolverCountLimit"`: The maximum number of resolvers that can be invoked in a single
request. The default value is 0 (or unspecified), which will set the limit to 10000. When
specified, the limit value can be between 1 and 10000. This field will produce a limit
error if the operation falls out of bounds.
- `"tags"`: A TagMap object.
- `"userPoolConfig"`: The Amazon Cognito user pool configuration.
- `"visibility"`: Sets the value of the GraphQL API to public (GLOBAL) or private
(PRIVATE). If no value is provided, the visibility will be set to GLOBAL by default. This
value cannot be changed once the API has been created.
- `"xrayEnabled"`: A flag indicating whether to use X-Ray tracing for the GraphqlApi.
"""
function create_graphql_api(
authenticationType, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis",
Dict{String,Any}("authenticationType" => authenticationType, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_graphql_api(
authenticationType,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"authenticationType" => authenticationType, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_resolver(api_id, field_name, type_name)
create_resolver(api_id, field_name, type_name, params::Dict{String,<:Any})
Creates a Resolver object. A resolver converts incoming requests into a format that a data
source can understand, and converts the data source's responses into GraphQL.
# Arguments
- `api_id`: The ID for the GraphQL API for which the resolver is being created.
- `field_name`: The name of the field to attach the resolver to.
- `type_name`: The name of the Type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cachingConfig"`: The caching configuration for the resolver.
- `"code"`: The resolver code that contains the request and response functions. When code
is used, the runtime is required. The runtime value must be APPSYNC_JS.
- `"dataSourceName"`: The name of the data source for which the resolver is being created.
- `"kind"`: The resolver type. UNIT: A UNIT resolver type. A UNIT resolver is the
default resolver type. You can use a UNIT resolver to run a GraphQL query against a single
data source. PIPELINE: A PIPELINE resolver type. You can use a PIPELINE resolver to
invoke a series of Function objects in a serial manner. You can use a pipeline resolver to
run a GraphQL query against multiple data sources.
- `"maxBatchSize"`: The maximum batching size for a resolver.
- `"metricsConfig"`: Enables or disables enhanced resolver metrics for specified resolvers.
Note that metricsConfig won't be used unless the resolverLevelMetricsBehavior value is set
to PER_RESOLVER_METRICS. If the resolverLevelMetricsBehavior is set to
FULL_REQUEST_RESOLVER_METRICS instead, metricsConfig will be ignored. However, you can
still set its value. metricsConfig can be ENABLED or DISABLED.
- `"pipelineConfig"`: The PipelineConfig.
- `"requestMappingTemplate"`: The mapping template to use for requests. A resolver uses a
request mapping template to convert a GraphQL expression into a format that a data source
can understand. Mapping templates are written in Apache Velocity Template Language (VTL).
VTL request mapping templates are optional when using an Lambda data source. For all other
data sources, VTL request and response mapping templates are required.
- `"responseMappingTemplate"`: The mapping template to use for responses from the data
source.
- `"runtime"`:
- `"syncConfig"`: The SyncConfig for a resolver attached to a versioned data source.
"""
function create_resolver(
apiId, fieldName, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers",
Dict{String,Any}("fieldName" => fieldName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_resolver(
apiId,
fieldName,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("fieldName" => fieldName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_type(api_id, definition, format)
create_type(api_id, definition, format, params::Dict{String,<:Any})
Creates a Type object.
# Arguments
- `api_id`: The API ID.
- `definition`: The type definition, in GraphQL Schema Definition Language (SDL) format.
For more information, see the GraphQL SDL documentation.
- `format`: The type format: SDL or JSON.
"""
function create_type(
apiId, definition, format; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types",
Dict{String,Any}("definition" => definition, "format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_type(
apiId,
definition,
format,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("definition" => definition, "format" => format),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api_cache(api_id)
delete_api_cache(api_id, params::Dict{String,<:Any})
Deletes an ApiCache object.
# Arguments
- `api_id`: The API ID.
"""
function delete_api_cache(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)/ApiCaches";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api_cache(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/ApiCaches",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api_key(api_id, id)
delete_api_key(api_id, id, params::Dict{String,<:Any})
Deletes an API key.
# Arguments
- `api_id`: The API ID.
- `id`: The ID for the API key.
"""
function delete_api_key(apiId, id; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)/apikeys/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api_key(
apiId,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/apikeys/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_data_source(api_id, name)
delete_data_source(api_id, name, params::Dict{String,<:Any})
Deletes a DataSource object.
# Arguments
- `api_id`: The API ID.
- `name`: The name of the data source.
"""
function delete_data_source(apiId, name; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)/datasources/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_data_source(
apiId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/datasources/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain_name(domain_name)
delete_domain_name(domain_name, params::Dict{String,<:Any})
Deletes a custom DomainName object.
# Arguments
- `domain_name`: The domain name.
"""
function delete_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_function(api_id, function_id)
delete_function(api_id, function_id, params::Dict{String,<:Any})
Deletes a Function.
# Arguments
- `api_id`: The GraphQL API ID.
- `function_id`: The Function ID.
"""
function delete_function(
apiId, functionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/functions/$(functionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_function(
apiId,
functionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/functions/$(functionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_graphql_api(api_id)
delete_graphql_api(api_id, params::Dict{String,<:Any})
Deletes a GraphqlApi object.
# Arguments
- `api_id`: The API ID.
"""
function delete_graphql_api(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_graphql_api(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resolver(api_id, field_name, type_name)
delete_resolver(api_id, field_name, type_name, params::Dict{String,<:Any})
Deletes a Resolver object.
# Arguments
- `api_id`: The API ID.
- `field_name`: The resolver field name.
- `type_name`: The name of the resolver type.
"""
function delete_resolver(
apiId, fieldName, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resolver(
apiId,
fieldName,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_type(api_id, type_name)
delete_type(api_id, type_name, params::Dict{String,<:Any})
Deletes a Type object.
# Arguments
- `api_id`: The API ID.
- `type_name`: The type name.
"""
function delete_type(apiId, typeName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)/types/$(typeName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_type(
apiId,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/types/$(typeName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_api(domain_name)
disassociate_api(domain_name, params::Dict{String,<:Any})
Removes an ApiAssociation object from a custom domain.
# Arguments
- `domain_name`: The domain name.
"""
function disassociate_api(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/domainnames/$(domainName)/apiassociation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_api(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/domainnames/$(domainName)/apiassociation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_merged_graphql_api(association_id, source_api_identifier)
disassociate_merged_graphql_api(association_id, source_api_identifier, params::Dict{String,<:Any})
Deletes an association between a Merged API and source API using the source API's
identifier and the association ID.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `source_api_identifier`: The identifier of the AppSync Source API. This is generated by
the AppSync service. In most cases, source APIs (especially in your account) only require
the API ID value or ARN of the source API. However, source APIs from other accounts
(cross-account use cases) strictly require the full resource ARN of the source API.
"""
function disassociate_merged_graphql_api(
associationId, sourceApiIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/sourceApis/$(sourceApiIdentifier)/mergedApiAssociations/$(associationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_merged_graphql_api(
associationId,
sourceApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/sourceApis/$(sourceApiIdentifier)/mergedApiAssociations/$(associationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_source_graphql_api(association_id, merged_api_identifier)
disassociate_source_graphql_api(association_id, merged_api_identifier, params::Dict{String,<:Any})
Deletes an association between a Merged API and source API using the Merged API's
identifier and the association ID.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
"""
function disassociate_source_graphql_api(
associationId, mergedApiIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_source_graphql_api(
associationId,
mergedApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
evaluate_code(code, context, runtime)
evaluate_code(code, context, runtime, params::Dict{String,<:Any})
Evaluates the given code and returns the response. The code definition requirements depend
on the specified runtime. For APPSYNC_JS runtimes, the code defines the request and
response functions. The request function takes the incoming request after a GraphQL
operation is parsed and converts it into a request configuration for the selected data
source operation. The response function interprets responses from the data source and maps
it to the shape of the GraphQL field output type.
# Arguments
- `code`: The code definition to be evaluated. Note that code and runtime are both required
for this action. The runtime value must be APPSYNC_JS.
- `context`: The map that holds all of the contextual information for your resolver
invocation. A context is required for this action.
- `runtime`: The runtime to be used when evaluating the code. Currently, only the
APPSYNC_JS runtime is supported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"function"`: The function within the code to be evaluated. If provided, the valid values
are request and response.
"""
function evaluate_code(
code, context, runtime; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/dataplane-evaluatecode",
Dict{String,Any}("code" => code, "context" => context, "runtime" => runtime);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function evaluate_code(
code,
context,
runtime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/dataplane-evaluatecode",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"code" => code, "context" => context, "runtime" => runtime
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
evaluate_mapping_template(context, template)
evaluate_mapping_template(context, template, params::Dict{String,<:Any})
Evaluates a given template and returns the response. The mapping template can be a request
or response template. Request templates take the incoming request after a GraphQL operation
is parsed and convert it into a request configuration for the selected data source
operation. Response templates interpret responses from the data source and map it to the
shape of the GraphQL field output type. Mapping templates are written in the Apache
Velocity Template Language (VTL).
# Arguments
- `context`: The map that holds all of the contextual information for your resolver
invocation. A context is required for this action.
- `template`: The mapping template; this can be a request or response template. A template
is required for this action.
"""
function evaluate_mapping_template(
context, template; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/dataplane-evaluatetemplate",
Dict{String,Any}("context" => context, "template" => template);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function evaluate_mapping_template(
context,
template,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/dataplane-evaluatetemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("context" => context, "template" => template),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
flush_api_cache(api_id)
flush_api_cache(api_id, params::Dict{String,<:Any})
Flushes an ApiCache object.
# Arguments
- `api_id`: The API ID.
"""
function flush_api_cache(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"DELETE",
"/v1/apis/$(apiId)/FlushCache";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function flush_api_cache(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/apis/$(apiId)/FlushCache",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api_association(domain_name)
get_api_association(domain_name, params::Dict{String,<:Any})
Retrieves an ApiAssociation object.
# Arguments
- `domain_name`: The domain name.
"""
function get_api_association(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/domainnames/$(domainName)/apiassociation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_api_association(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/domainnames/$(domainName)/apiassociation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_api_cache(api_id)
get_api_cache(api_id, params::Dict{String,<:Any})
Retrieves an ApiCache object.
# Arguments
- `api_id`: The API ID.
"""
function get_api_cache(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/ApiCaches";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_api_cache(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/ApiCaches",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_data_source(api_id, name)
get_data_source(api_id, name, params::Dict{String,<:Any})
Retrieves a DataSource object.
# Arguments
- `api_id`: The API ID.
- `name`: The name of the data source.
"""
function get_data_source(apiId, name; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/datasources/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_source(
apiId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/datasources/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_data_source_introspection(introspection_id)
get_data_source_introspection(introspection_id, params::Dict{String,<:Any})
Retrieves the record of an existing introspection. If the retrieval is successful, the
result of the instrospection will also be returned. If the retrieval fails the operation,
an error message will be returned instead.
# Arguments
- `introspection_id`: The introspection ID. Each introspection contains a unique ID that
can be used to reference the instrospection record.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeModelsSDL"`: A boolean flag that determines whether SDL should be generated for
introspected types or not. If set to true, each model will contain an sdl property that
contains the SDL for that type. The SDL only contains the type data and no additional
metadata or directives.
- `"maxResults"`: The maximum number of introspected types that will be returned in a
single response.
- `"nextToken"`: Determines the number of types to be returned in a single response before
paginating. This value is typically taken from nextToken value from the previous response.
"""
function get_data_source_introspection(
introspectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/datasources/introspections/$(introspectionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_source_introspection(
introspectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/datasources/introspections/$(introspectionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_name(domain_name)
get_domain_name(domain_name, params::Dict{String,<:Any})
Retrieves a custom DomainName object.
# Arguments
- `domain_name`: The domain name.
"""
function get_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_function(api_id, function_id)
get_function(api_id, function_id, params::Dict{String,<:Any})
Get a Function.
# Arguments
- `api_id`: The GraphQL API ID.
- `function_id`: The Function ID.
"""
function get_function(apiId, functionId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/functions/$(functionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_function(
apiId,
functionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/functions/$(functionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_graphql_api(api_id)
get_graphql_api(api_id, params::Dict{String,<:Any})
Retrieves a GraphqlApi object.
# Arguments
- `api_id`: The API ID for the GraphQL API.
"""
function get_graphql_api(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET", "/v1/apis/$(apiId)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_graphql_api(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_graphql_api_environment_variables(api_id)
get_graphql_api_environment_variables(api_id, params::Dict{String,<:Any})
Retrieves the list of environmental variable key-value pairs associated with an API by its
ID value.
# Arguments
- `api_id`: The ID of the API from which the environmental variable list will be retrieved.
"""
function get_graphql_api_environment_variables(
apiId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/environmentVariables";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_graphql_api_environment_variables(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/environmentVariables",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_introspection_schema(api_id, format)
get_introspection_schema(api_id, format, params::Dict{String,<:Any})
Retrieves the introspection schema for a GraphQL API.
# Arguments
- `api_id`: The API ID.
- `format`: The schema format: SDL or JSON.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeDirectives"`: A flag that specifies whether the schema introspection should
contain directives.
"""
function get_introspection_schema(
apiId, format; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/schema",
Dict{String,Any}("format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_introspection_schema(
apiId,
format,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/schema",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("format" => format), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resolver(api_id, field_name, type_name)
get_resolver(api_id, field_name, type_name, params::Dict{String,<:Any})
Retrieves a Resolver object.
# Arguments
- `api_id`: The API ID.
- `field_name`: The resolver field name.
- `type_name`: The resolver type name.
"""
function get_resolver(
apiId, fieldName, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resolver(
apiId,
fieldName,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_schema_creation_status(api_id)
get_schema_creation_status(api_id, params::Dict{String,<:Any})
Retrieves the current status of a schema creation operation.
# Arguments
- `api_id`: The API ID.
"""
function get_schema_creation_status(
apiId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/schemacreation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_schema_creation_status(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/schemacreation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_source_api_association(association_id, merged_api_identifier)
get_source_api_association(association_id, merged_api_identifier, params::Dict{String,<:Any})
Retrieves a SourceApiAssociation object.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
"""
function get_source_api_association(
associationId, mergedApiIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_source_api_association(
associationId,
mergedApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_type(api_id, format, type_name)
get_type(api_id, format, type_name, params::Dict{String,<:Any})
Retrieves a Type object.
# Arguments
- `api_id`: The API ID.
- `format`: The type format: SDL or JSON.
- `type_name`: The type name.
"""
function get_type(
apiId, format, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)",
Dict{String,Any}("format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_type(
apiId,
format,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("format" => format), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_api_keys(api_id)
list_api_keys(api_id, params::Dict{String,<:Any})
Lists the API keys for a given API. API keys are deleted automatically 60 days after they
expire. However, they may still be included in the response until they have actually been
deleted. You can safely call DeleteApiKey to manually delete a key before it's
automatically deleted.
# Arguments
- `api_id`: The API ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_api_keys(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/apikeys";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_api_keys(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/apikeys",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_data_sources(api_id)
list_data_sources(api_id, params::Dict{String,<:Any})
Lists the data sources for a given API.
# Arguments
- `api_id`: The API ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_data_sources(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/datasources";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_data_sources(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/datasources",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_domain_names()
list_domain_names(params::Dict{String,<:Any})
Lists multiple custom domain names.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_domain_names(; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET", "/v1/domainnames"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_domain_names(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/domainnames",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_functions(api_id)
list_functions(api_id, params::Dict{String,<:Any})
List multiple functions.
# Arguments
- `api_id`: The GraphQL API ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_functions(apiId; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/functions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_functions(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/functions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_graphql_apis()
list_graphql_apis(params::Dict{String,<:Any})
Lists your GraphQL APIs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"apiType"`: The value that indicates whether the GraphQL API is a standard API (GRAPHQL)
or merged API (MERGED).
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
- `"owner"`: The account owner of the GraphQL API.
"""
function list_graphql_apis(; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET", "/v1/apis"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_graphql_apis(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET", "/v1/apis", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_resolvers(api_id, type_name)
list_resolvers(api_id, type_name, params::Dict{String,<:Any})
Lists the resolvers for a given API and type.
# Arguments
- `api_id`: The API ID.
- `type_name`: The type name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_resolvers(apiId, typeName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resolvers(
apiId,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resolvers_by_function(api_id, function_id)
list_resolvers_by_function(api_id, function_id, params::Dict{String,<:Any})
List the resolvers that are associated with a specific function.
# Arguments
- `api_id`: The API ID.
- `function_id`: The function ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_resolvers_by_function(
apiId, functionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/functions/$(functionId)/resolvers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resolvers_by_function(
apiId,
functionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/functions/$(functionId)/resolvers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_source_api_associations(api_id)
list_source_api_associations(api_id, params::Dict{String,<:Any})
Lists the SourceApiAssociationSummary data.
# Arguments
- `api_id`: The API ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_source_api_associations(
apiId; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/sourceApiAssociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_source_api_associations(
apiId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/apis/$(apiId)/sourceApiAssociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists the tags for a resource.
# Arguments
- `resource_arn`: The GraphqlApi Amazon Resource Name (ARN).
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"GET",
"/v1/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_types(api_id, format)
list_types(api_id, format, params::Dict{String,<:Any})
Lists the types for a given API.
# Arguments
- `api_id`: The API ID.
- `format`: The type format: SDL or JSON.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_types(apiId, format; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"GET",
"/v1/apis/$(apiId)/types",
Dict{String,Any}("format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_types(
apiId,
format,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/apis/$(apiId)/types",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("format" => format), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_types_by_association(association_id, format, merged_api_identifier)
list_types_by_association(association_id, format, merged_api_identifier, params::Dict{String,<:Any})
Lists Type objects by the source API association ID.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `format`: The format type.
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that you want the request to return.
- `"nextToken"`: An identifier that was returned from the previous call to this operation,
which you can use to return the next set of items in the list.
"""
function list_types_by_association(
associationId,
format,
mergedApiIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)/types",
Dict{String,Any}("format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_types_by_association(
associationId,
format,
mergedApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"GET",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)/types",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("format" => format), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_graphql_api_environment_variables(api_id, environment_variables)
put_graphql_api_environment_variables(api_id, environment_variables, params::Dict{String,<:Any})
Creates a list of environmental variables in an API by its ID value. When creating an
environmental variable, it must follow the constraints below: Both JavaScript and VTL
templates support environmental variables. Environmental variables are not evaluated
before function invocation. Environmental variables only support string values. Any
defined value in an environmental variable is considered a string literal and not expanded.
Variable evaluations should ideally be performed in the function code. When creating an
environmental variable key-value pair, it must follow the additional constraints below:
Keys must begin with a letter. Keys must be at least two characters long. Keys can only
contain letters, numbers, and the underscore character (_). Values can be up to 512
characters long. You can configure up to 50 key-value pairs in a GraphQL API. You can
create a list of environmental variables by adding it to the environmentVariables payload
as a list in the format {\"key1\":\"value1\",\"key2\":\"value2\", …}. Note that each call
of the PutGraphqlApiEnvironmentVariables action will result in the overwriting of the
existing environmental variable list of that API. This means the existing environmental
variables will be lost. To avoid this, you must include all existing and new environmental
variables in the list each time you call this action.
# Arguments
- `api_id`: The ID of the API to which the environmental variable list will be written.
- `environment_variables`: The list of environmental variables to add to the API. When
creating an environmental variable key-value pair, it must follow the additional
constraints below: Keys must begin with a letter. Keys must be at least two characters
long. Keys can only contain letters, numbers, and the underscore character (_). Values
can be up to 512 characters long. You can configure up to 50 key-value pairs in a GraphQL
API. You can create a list of environmental variables by adding it to the
environmentVariables payload as a list in the format
{\"key1\":\"value1\",\"key2\":\"value2\", …}. Note that each call of the
PutGraphqlApiEnvironmentVariables action will result in the overwriting of the existing
environmental variable list of that API. This means the existing environmental variables
will be lost. To avoid this, you must include all existing and new environmental variables
in the list each time you call this action.
"""
function put_graphql_api_environment_variables(
apiId, environmentVariables; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"PUT",
"/v1/apis/$(apiId)/environmentVariables",
Dict{String,Any}("environmentVariables" => environmentVariables);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_graphql_api_environment_variables(
apiId,
environmentVariables,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"PUT",
"/v1/apis/$(apiId)/environmentVariables",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("environmentVariables" => environmentVariables),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_data_source_introspection()
start_data_source_introspection(params::Dict{String,<:Any})
Creates a new introspection. Returns the introspectionId of the new introspection after its
creation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"rdsDataApiConfig"`: The rdsDataApiConfig object data.
"""
function start_data_source_introspection(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/datasources/introspections";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_data_source_introspection(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/datasources/introspections",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_schema_creation(api_id, definition)
start_schema_creation(api_id, definition, params::Dict{String,<:Any})
Adds a new schema to your GraphQL API. This operation is asynchronous. Use to determine
when it has completed.
# Arguments
- `api_id`: The API ID.
- `definition`: The schema definition, in GraphQL schema language format.
"""
function start_schema_creation(
apiId, definition; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/schemacreation",
Dict{String,Any}("definition" => definition);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_schema_creation(
apiId,
definition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/schemacreation",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("definition" => definition), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_schema_merge(association_id, merged_api_identifier)
start_schema_merge(association_id, merged_api_identifier, params::Dict{String,<:Any})
Initiates a merge operation. Returns a status that shows the result of the merge operation.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
"""
function start_schema_merge(
associationId, mergedApiIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)/merge";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_schema_merge(
associationId,
mergedApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)/merge",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tags a resource with user-supplied tags.
# Arguments
- `resource_arn`: The GraphqlApi Amazon Resource Name (ARN).
- `tags`: A TagMap object.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"POST",
"/v1/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Untags a resource.
# Arguments
- `resource_arn`: The GraphqlApi Amazon Resource Name (ARN).
- `tag_keys`: A list of TagKey objects.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"DELETE",
"/v1/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"DELETE",
"/v1/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_api_cache(api_caching_behavior, api_id, ttl, type)
update_api_cache(api_caching_behavior, api_id, ttl, type, params::Dict{String,<:Any})
Updates the cache for the GraphQL API.
# Arguments
- `api_caching_behavior`: Caching behavior. FULL_REQUEST_CACHING: All requests are fully
cached. PER_RESOLVER_CACHING: Individual resolvers that you specify are cached.
- `api_id`: The GraphQL API ID.
- `ttl`: TTL in seconds for cache entries. Valid values are 1–3,600 seconds.
- `type`: The cache instance type. Valid values are SMALL MEDIUM LARGE
XLARGE LARGE_2X LARGE_4X LARGE_8X (not available in all regions) LARGE_12X
Historically, instance types were identified by an EC2-style value. As of July 2020, this
is deprecated, and the generic identifiers above should be used. The following legacy
instance types are available, but their use is discouraged: T2_SMALL: A t2.small
instance type. T2_MEDIUM: A t2.medium instance type. R4_LARGE: A r4.large instance
type. R4_XLARGE: A r4.xlarge instance type. R4_2XLARGE: A r4.2xlarge instance type.
R4_4XLARGE: A r4.4xlarge instance type. R4_8XLARGE: A r4.8xlarge instance type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"healthMetricsConfig"`: Controls how cache health metrics will be emitted to CloudWatch.
Cache health metrics include: NetworkBandwidthOutAllowanceExceeded: The network packets
dropped because the throughput exceeded the aggregated bandwidth limit. This is useful for
diagnosing bottlenecks in a cache configuration. EngineCPUUtilization: The CPU
utilization (percentage) allocated to the Redis process. This is useful for diagnosing
bottlenecks in a cache configuration. Metrics will be recorded by API ID. You can set the
value to ENABLED or DISABLED.
"""
function update_api_cache(
apiCachingBehavior, apiId, ttl, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/ApiCaches/update",
Dict{String,Any}(
"apiCachingBehavior" => apiCachingBehavior, "ttl" => ttl, "type" => type
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_api_cache(
apiCachingBehavior,
apiId,
ttl,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/ApiCaches/update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"apiCachingBehavior" => apiCachingBehavior, "ttl" => ttl, "type" => type
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_api_key(api_id, id)
update_api_key(api_id, id, params::Dict{String,<:Any})
Updates an API key. You can update the key as long as it's not deleted.
# Arguments
- `api_id`: The ID for the GraphQL API.
- `id`: The API key ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the purpose of the API key.
- `"expires"`: From the update time, the time after which the API key expires. The date is
represented as seconds since the epoch. For more information, see .
"""
function update_api_key(apiId, id; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"POST",
"/v1/apis/$(apiId)/apikeys/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_api_key(
apiId,
id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/apikeys/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_data_source(api_id, name, type)
update_data_source(api_id, name, type, params::Dict{String,<:Any})
Updates a DataSource object.
# Arguments
- `api_id`: The API ID.
- `name`: The new name for the data source.
- `type`: The new data source type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The new description for the data source.
- `"dynamodbConfig"`: The new Amazon DynamoDB configuration.
- `"elasticsearchConfig"`: The new OpenSearch configuration. As of September 2021, Amazon
Elasticsearch service is Amazon OpenSearch Service. This configuration is deprecated.
Instead, use UpdateDataSourceRequestopenSearchServiceConfig to update an OpenSearch data
source.
- `"eventBridgeConfig"`: The new Amazon EventBridge settings.
- `"httpConfig"`: The new HTTP endpoint configuration.
- `"lambdaConfig"`: The new Lambda configuration.
- `"metricsConfig"`: Enables or disables enhanced data source metrics for specified data
sources. Note that metricsConfig won't be used unless the dataSourceLevelMetricsBehavior
value is set to PER_DATA_SOURCE_METRICS. If the dataSourceLevelMetricsBehavior is set to
FULL_REQUEST_DATA_SOURCE_METRICS instead, metricsConfig will be ignored. However, you can
still set its value. metricsConfig can be ENABLED or DISABLED.
- `"openSearchServiceConfig"`: The new OpenSearch configuration.
- `"relationalDatabaseConfig"`: The new relational database configuration.
- `"serviceRoleArn"`: The new service role Amazon Resource Name (ARN) for the data source.
"""
function update_data_source(
apiId, name, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/datasources/$(name)",
Dict{String,Any}("type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_data_source(
apiId,
name,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/datasources/$(name)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("type" => type), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_domain_name(domain_name)
update_domain_name(domain_name, params::Dict{String,<:Any})
Updates a custom DomainName object.
# Arguments
- `domain_name`: The domain name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the DomainName.
"""
function update_domain_name(domainName; aws_config::AbstractAWSConfig=global_aws_config())
return appsync(
"POST",
"/v1/domainnames/$(domainName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_domain_name(
domainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/domainnames/$(domainName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_function(api_id, data_source_name, function_id, name)
update_function(api_id, data_source_name, function_id, name, params::Dict{String,<:Any})
Updates a Function object.
# Arguments
- `api_id`: The GraphQL API ID.
- `data_source_name`: The Function DataSource name.
- `function_id`: The function ID.
- `name`: The Function name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"code"`: The function code that contains the request and response functions. When code
is used, the runtime is required. The runtime value must be APPSYNC_JS.
- `"description"`: The Function description.
- `"functionVersion"`: The version of the request mapping template. Currently, the
supported value is 2018-05-29. Note that when using VTL and mapping templates, the
functionVersion is required.
- `"maxBatchSize"`: The maximum batching size for a resolver.
- `"requestMappingTemplate"`: The Function request mapping template. Functions support only
the 2018-05-29 version of the request mapping template.
- `"responseMappingTemplate"`: The Function request mapping template.
- `"runtime"`:
- `"syncConfig"`:
"""
function update_function(
apiId,
dataSourceName,
functionId,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/functions/$(functionId)",
Dict{String,Any}("dataSourceName" => dataSourceName, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_function(
apiId,
dataSourceName,
functionId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/functions/$(functionId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("dataSourceName" => dataSourceName, "name" => name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_graphql_api(api_id, authentication_type, name)
update_graphql_api(api_id, authentication_type, name, params::Dict{String,<:Any})
Updates a GraphqlApi object.
# Arguments
- `api_id`: The API ID.
- `authentication_type`: The new authentication type for the GraphqlApi object.
- `name`: The new name for the GraphqlApi object.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalAuthenticationProviders"`: A list of additional authentication providers for
the GraphqlApi API.
- `"enhancedMetricsConfig"`: The enhancedMetricsConfig object.
- `"introspectionConfig"`: Sets the value of the GraphQL API to enable (ENABLED) or disable
(DISABLED) introspection. If no value is provided, the introspection configuration will be
set to ENABLED by default. This field will produce an error if the operation attempts to
use the introspection feature while this field is disabled. For more information about
introspection, see GraphQL introspection.
- `"lambdaAuthorizerConfig"`: Configuration for Lambda function authorization.
- `"logConfig"`: The Amazon CloudWatch Logs configuration for the GraphqlApi object.
- `"mergedApiExecutionRoleArn"`: The Identity and Access Management service role ARN for a
merged API. The AppSync service assumes this role on behalf of the Merged API to validate
access to source APIs at runtime and to prompt the AUTO_MERGE to update the merged API
endpoint with the source API changes automatically.
- `"openIDConnectConfig"`: The OpenID Connect configuration for the GraphqlApi object.
- `"ownerContact"`: The owner contact information for an API resource. This field accepts
any string input with a length of 0 - 256 characters.
- `"queryDepthLimit"`: The maximum depth a query can have in a single request. Depth refers
to the amount of nested levels allowed in the body of query. The default value is 0 (or
unspecified), which indicates there's no depth limit. If you set a limit, it can be between
1 and 75 nested levels. This field will produce a limit error if the operation falls out of
bounds. Note that fields can still be set to nullable or non-nullable. If a non-nullable
field produces an error, the error will be thrown upwards to the first nullable field
available.
- `"resolverCountLimit"`: The maximum number of resolvers that can be invoked in a single
request. The default value is 0 (or unspecified), which will set the limit to 10000. When
specified, the limit value can be between 1 and 10000. This field will produce a limit
error if the operation falls out of bounds.
- `"userPoolConfig"`: The new Amazon Cognito user pool configuration for the ~GraphqlApi
object.
- `"xrayEnabled"`: A flag indicating whether to use X-Ray tracing for the GraphqlApi.
"""
function update_graphql_api(
apiId, authenticationType, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)",
Dict{String,Any}("authenticationType" => authenticationType, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_graphql_api(
apiId,
authenticationType,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"authenticationType" => authenticationType, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_resolver(api_id, field_name, type_name)
update_resolver(api_id, field_name, type_name, params::Dict{String,<:Any})
Updates a Resolver object.
# Arguments
- `api_id`: The API ID.
- `field_name`: The new field name.
- `type_name`: The new type name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cachingConfig"`: The caching configuration for the resolver.
- `"code"`: The resolver code that contains the request and response functions. When code
is used, the runtime is required. The runtime value must be APPSYNC_JS.
- `"dataSourceName"`: The new data source name.
- `"kind"`: The resolver type. UNIT: A UNIT resolver type. A UNIT resolver is the
default resolver type. You can use a UNIT resolver to run a GraphQL query against a single
data source. PIPELINE: A PIPELINE resolver type. You can use a PIPELINE resolver to
invoke a series of Function objects in a serial manner. You can use a pipeline resolver to
run a GraphQL query against multiple data sources.
- `"maxBatchSize"`: The maximum batching size for a resolver.
- `"metricsConfig"`: Enables or disables enhanced resolver metrics for specified resolvers.
Note that metricsConfig won't be used unless the resolverLevelMetricsBehavior value is set
to PER_RESOLVER_METRICS. If the resolverLevelMetricsBehavior is set to
FULL_REQUEST_RESOLVER_METRICS instead, metricsConfig will be ignored. However, you can
still set its value. metricsConfig can be ENABLED or DISABLED.
- `"pipelineConfig"`: The PipelineConfig.
- `"requestMappingTemplate"`: The new request mapping template. A resolver uses a request
mapping template to convert a GraphQL expression into a format that a data source can
understand. Mapping templates are written in Apache Velocity Template Language (VTL). VTL
request mapping templates are optional when using an Lambda data source. For all other data
sources, VTL request and response mapping templates are required.
- `"responseMappingTemplate"`: The new response mapping template.
- `"runtime"`:
- `"syncConfig"`: The SyncConfig for a resolver attached to a versioned data source.
"""
function update_resolver(
apiId, fieldName, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_resolver(
apiId,
fieldName,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)/resolvers/$(fieldName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_source_api_association(association_id, merged_api_identifier)
update_source_api_association(association_id, merged_api_identifier, params::Dict{String,<:Any})
Updates some of the configuration choices of a particular source API association.
# Arguments
- `association_id`: The ID generated by the AppSync service for the source API association.
- `merged_api_identifier`: The identifier of the AppSync Merged API. This is generated by
the AppSync service. In most cases, Merged APIs (especially in your account) only require
the API ID value or ARN of the merged API. However, Merged APIs in other accounts
(cross-account use cases) strictly require the full resource ARN of the merged API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description field.
- `"sourceApiAssociationConfig"`: The SourceApiAssociationConfig object data.
"""
function update_source_api_association(
associationId, mergedApiIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_source_api_association(
associationId,
mergedApiIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/mergedApis/$(mergedApiIdentifier)/sourceApiAssociations/$(associationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_type(api_id, format, type_name)
update_type(api_id, format, type_name, params::Dict{String,<:Any})
Updates a Type object.
# Arguments
- `api_id`: The API ID.
- `format`: The new type format: SDL or JSON.
- `type_name`: The new type name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"definition"`: The new definition.
"""
function update_type(
apiId, format, typeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)",
Dict{String,Any}("format" => format);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_type(
apiId,
format,
typeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return appsync(
"POST",
"/v1/apis/$(apiId)/types/$(typeName)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("format" => format), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 24781 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: apptest
using AWS.Compat
using AWS.UUIDs
"""
create_test_case(name, steps)
create_test_case(name, steps, params::Dict{String,<:Any})
Creates a test case.
# Arguments
- `name`: The name of the test case.
- `steps`: The steps in the test case.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The client token of the test case.
- `"description"`: The description of the test case.
- `"tags"`: The specified tags of the test case.
"""
function create_test_case(name, steps; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"POST",
"/testcase",
Dict{String,Any}(
"name" => name, "steps" => steps, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_test_case(
name,
steps,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"POST",
"/testcase",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name, "steps" => steps, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_test_configuration(name, resources)
create_test_configuration(name, resources, params::Dict{String,<:Any})
Creates a test configuration.
# Arguments
- `name`: The name of the test configuration.
- `resources`: The defined resources of the test configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The client token of the test configuration.
- `"description"`: The description of the test configuration.
- `"properties"`: The properties of the test configuration.
- `"serviceSettings"`: The service settings of the test configuration.
- `"tags"`: The tags of the test configuration.
"""
function create_test_configuration(
name, resources; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"POST",
"/testconfiguration",
Dict{String,Any}(
"name" => name, "resources" => resources, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_test_configuration(
name,
resources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"POST",
"/testconfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name,
"resources" => resources,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_test_suite(name, test_cases)
create_test_suite(name, test_cases, params::Dict{String,<:Any})
Creates a test suite.
# Arguments
- `name`: The name of the test suite.
- `test_cases`: The test cases in the test suite.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"afterSteps"`: The after steps of the test suite.
- `"beforeSteps"`: The before steps of the test suite.
- `"clientToken"`: The client token of the test suite.
- `"description"`: The description of the test suite.
- `"tags"`: The tags of the test suite.
"""
function create_test_suite(
name, testCases; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"POST",
"/testsuite",
Dict{String,Any}(
"name" => name, "testCases" => testCases, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_test_suite(
name,
testCases,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"POST",
"/testsuite",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name,
"testCases" => testCases,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_test_case(test_case_id)
delete_test_case(test_case_id, params::Dict{String,<:Any})
Deletes a test case.
# Arguments
- `test_case_id`: The test case ID of the test case.
"""
function delete_test_case(testCaseId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"DELETE",
"/testcases/$(testCaseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_test_case(
testCaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"DELETE",
"/testcases/$(testCaseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_test_configuration(test_configuration_id)
delete_test_configuration(test_configuration_id, params::Dict{String,<:Any})
Deletes a test configuration.
# Arguments
- `test_configuration_id`: The test ID of the test configuration.
"""
function delete_test_configuration(
testConfigurationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"DELETE",
"/testconfigurations/$(testConfigurationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_test_configuration(
testConfigurationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"DELETE",
"/testconfigurations/$(testConfigurationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_test_run(test_run_id)
delete_test_run(test_run_id, params::Dict{String,<:Any})
Deletes a test run.
# Arguments
- `test_run_id`: The run ID of the test run.
"""
function delete_test_run(testRunId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"DELETE",
"/testruns/$(testRunId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_test_run(
testRunId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"DELETE",
"/testruns/$(testRunId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_test_suite(test_suite_id)
delete_test_suite(test_suite_id, params::Dict{String,<:Any})
Deletes a test suite.
# Arguments
- `test_suite_id`: The test ID of the test suite.
"""
function delete_test_suite(testSuiteId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"DELETE",
"/testsuites/$(testSuiteId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_test_suite(
testSuiteId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"DELETE",
"/testsuites/$(testSuiteId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_test_case(test_case_id)
get_test_case(test_case_id, params::Dict{String,<:Any})
Gets a test case.
# Arguments
- `test_case_id`: The request test ID of the test case.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"testCaseVersion"`: The test case version of the test case.
"""
function get_test_case(testCaseId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET",
"/testcases/$(testCaseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_test_case(
testCaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testcases/$(testCaseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_test_configuration(test_configuration_id)
get_test_configuration(test_configuration_id, params::Dict{String,<:Any})
Gets a test configuration.
# Arguments
- `test_configuration_id`: The request test configuration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"testConfigurationVersion"`: The test configuration version.
"""
function get_test_configuration(
testConfigurationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET",
"/testconfigurations/$(testConfigurationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_test_configuration(
testConfigurationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testconfigurations/$(testConfigurationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_test_run_step(step_name, test_run_id)
get_test_run_step(step_name, test_run_id, params::Dict{String,<:Any})
Gets a test run step.
# Arguments
- `step_name`: The step name of the test run step.
- `test_run_id`: The test run ID of the test run step.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"testCaseId"`: The test case ID of a test run step.
- `"testSuiteId"`: The test suite ID of a test run step.
"""
function get_test_run_step(
stepName, testRunId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET",
"/testruns/$(testRunId)/steps/$(stepName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_test_run_step(
stepName,
testRunId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testruns/$(testRunId)/steps/$(stepName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_test_suite(test_suite_id)
get_test_suite(test_suite_id, params::Dict{String,<:Any})
Gets a test suite.
# Arguments
- `test_suite_id`: The ID of the test suite.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"testSuiteVersion"`: The version of the test suite.
"""
function get_test_suite(testSuiteId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET",
"/testsuites/$(testSuiteId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_test_suite(
testSuiteId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testsuites/$(testSuiteId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists tags for a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_test_cases()
list_test_cases(params::Dict{String,<:Any})
Lists test cases.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum results of the test case.
- `"nextToken"`: The next token of the test cases.
- `"testCaseIds"`: The IDs of the test cases.
"""
function list_test_cases(; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET", "/testcases"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_test_cases(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET", "/testcases", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_test_configurations()
list_test_configurations(params::Dict{String,<:Any})
Lists test configurations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum results of the test configuration.
- `"nextToken"`: The next token for the test configurations.
- `"testConfigurationIds"`: The configuration IDs of the test configurations.
"""
function list_test_configurations(; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET", "/testconfigurations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_test_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET",
"/testconfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_test_run_steps(test_run_id)
list_test_run_steps(test_run_id, params::Dict{String,<:Any})
Lists test run steps.
# Arguments
- `test_run_id`: The test run ID of the test run steps.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of test run steps to return in one page of results.
- `"nextToken"`: The token from a previous step to retrieve the next page of results.
- `"testCaseId"`: The test case ID of the test run steps.
- `"testSuiteId"`: The test suite ID of the test run steps.
"""
function list_test_run_steps(testRunId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET",
"/testruns/$(testRunId)/steps";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_test_run_steps(
testRunId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testruns/$(testRunId)/steps",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_test_run_test_cases(test_run_id)
list_test_run_test_cases(test_run_id, params::Dict{String,<:Any})
Lists test run test cases.
# Arguments
- `test_run_id`: The test run ID of the test cases.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of test run test cases to return in one page of
results.
- `"nextToken"`: The token from a previous request to retrieve the next page of results.
"""
function list_test_run_test_cases(
testRunId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET",
"/testruns/$(testRunId)/testcases";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_test_run_test_cases(
testRunId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"GET",
"/testruns/$(testRunId)/testcases",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_test_runs()
list_test_runs(params::Dict{String,<:Any})
Lists test runs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of test runs to return in one page of results.
- `"nextToken"`: The token from the previous request to retrieve the next page of test run
results.
- `"testSuiteId"`: The test suite ID of the test runs.
- `"testrunIds"`: The test run IDs of the test runs.
"""
function list_test_runs(; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET", "/testruns"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_test_runs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET", "/testruns", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_test_suites()
list_test_suites(params::Dict{String,<:Any})
Lists test suites.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of test suites to return in one page of results.
- `"nextToken"`: The token from a previous request to retrieve the next page of results.
- `"testSuiteIds"`: The suite ID of the test suites.
"""
function list_test_suites(; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"GET", "/testsuites"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_test_suites(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"GET", "/testsuites", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
start_test_run(test_suite_id)
start_test_run(test_suite_id, params::Dict{String,<:Any})
Starts a test run.
# Arguments
- `test_suite_id`: The test suite ID of the test run.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: The client token of the test run.
- `"tags"`: The tags of the test run.
- `"testConfigurationId"`: The configuration ID of the test run.
"""
function start_test_run(testSuiteId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"POST",
"/testrun",
Dict{String,Any}("testSuiteId" => testSuiteId, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_test_run(
testSuiteId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"POST",
"/testrun",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"testSuiteId" => testSuiteId, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Specifies tags of a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the tag resource.
- `tags`: The tags of the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Untags a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tag_keys`: The tag keys of the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_test_case(test_case_id)
update_test_case(test_case_id, params::Dict{String,<:Any})
Updates a test case.
# Arguments
- `test_case_id`: The test case ID of the test case.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the test case.
- `"steps"`: The steps of the test case.
"""
function update_test_case(testCaseId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"PATCH",
"/testcases/$(testCaseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_test_case(
testCaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"PATCH",
"/testcases/$(testCaseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_test_configuration(test_configuration_id)
update_test_configuration(test_configuration_id, params::Dict{String,<:Any})
Updates a test configuration.
# Arguments
- `test_configuration_id`: The test configuration ID of the test configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the test configuration.
- `"properties"`: The properties of the test configuration.
- `"resources"`: The resources of the test configuration.
- `"serviceSettings"`: The service settings of the test configuration.
"""
function update_test_configuration(
testConfigurationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return apptest(
"PATCH",
"/testconfigurations/$(testConfigurationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_test_configuration(
testConfigurationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"PATCH",
"/testconfigurations/$(testConfigurationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_test_suite(test_suite_id)
update_test_suite(test_suite_id, params::Dict{String,<:Any})
Updates a test suite.
# Arguments
- `test_suite_id`: The test suite ID of the test suite.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"afterSteps"`: The after steps of the test suite.
- `"beforeSteps"`: The before steps for the test suite.
- `"description"`: The description of the test suite.
- `"testCases"`: The test cases in the test suite.
"""
function update_test_suite(testSuiteId; aws_config::AbstractAWSConfig=global_aws_config())
return apptest(
"PATCH",
"/testsuites/$(testSuiteId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_test_suite(
testSuiteId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return apptest(
"PATCH",
"/testsuites/$(testSuiteId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 24009 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: arc_zonal_shift
using AWS.Compat
using AWS.UUIDs
"""
cancel_zonal_shift(zonal_shift_id)
cancel_zonal_shift(zonal_shift_id, params::Dict{String,<:Any})
Cancel a zonal shift in Amazon Route 53 Application Recovery Controller. To cancel the
zonal shift, specify the zonal shift ID. A zonal shift can be one that you've started for a
resource in your Amazon Web Services account in an Amazon Web Services Region, or it can be
a zonal shift started by a practice run with zonal autoshift.
# Arguments
- `zonal_shift_id`: The internally-generated identifier of a zonal shift.
"""
function cancel_zonal_shift(zonalShiftId; aws_config::AbstractAWSConfig=global_aws_config())
return arc_zonal_shift(
"DELETE",
"/zonalshifts/$(zonalShiftId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_zonal_shift(
zonalShiftId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"DELETE",
"/zonalshifts/$(zonalShiftId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_practice_run_configuration(outcome_alarms, resource_identifier)
create_practice_run_configuration(outcome_alarms, resource_identifier, params::Dict{String,<:Any})
A practice run configuration for zonal autoshift is required when you enable zonal
autoshift. A practice run configuration includes specifications for blocked dates and
blocked time windows, and for Amazon CloudWatch alarms that you create to use with practice
runs. The alarms that you specify are an outcome alarm, to monitor application health
during practice runs and, optionally, a blocking alarm, to block practice runs from
starting. For more information, see Considerations when you configure zonal autoshift in
the Amazon Route 53 Application Recovery Controller Developer Guide.
# Arguments
- `outcome_alarms`: The outcome alarm for practice runs is a required Amazon CloudWatch
alarm that you specify that ends a practice run when the alarm is in an ALARM state.
Configure the alarm to monitor the health of your application when traffic is shifted away
from an Availability Zone during each weekly practice run. You should configure the alarm
to go into an ALARM state if your application is impacted by the zonal shift, and you want
to stop the zonal shift, to let traffic for the resource return to the Availability Zone.
- `resource_identifier`: The identifier of the resource to shift away traffic for when a
practice run starts a zonal shift. The identifier is the Amazon Resource Name (ARN) for the
resource. At this time, supported resources are Network Load Balancers and Application Load
Balancers with cross-zone load balancing turned off.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"blockedDates"`: Optionally, you can block Route 53 ARC from starting practice runs for
a resource on specific calendar dates. The format for blocked dates is: YYYY-MM-DD. Keep in
mind, when you specify dates, that dates and times for practice runs are in UTC. Separate
multiple blocked dates with spaces. For example, if you have an application update
scheduled to launch on May 1, 2024, and you don't want practice runs to shift traffic away
at that time, you could set a blocked date for 2024-05-01.
- `"blockedWindows"`: Optionally, you can block Route 53 ARC from starting practice runs
for specific windows of days and times. The format for blocked windows is:
DAY:HH:SS-DAY:HH:SS. Keep in mind, when you specify dates, that dates and times for
practice runs are in UTC. Also, be aware of potential time adjustments that might be
required for daylight saving time differences. Separate multiple blocked windows with
spaces. For example, say you run business report summaries three days a week. For this
scenario, you might set the following recurring days and times as blocked windows, for
example: MON-20:30-21:30 WED-20:30-21:30 FRI-20:30-21:30.
- `"blockingAlarms"`: An Amazon CloudWatch alarm that you can specify for zonal autoshift
practice runs. This alarm blocks Route 53 ARC from starting practice run zonal shifts, and
ends a practice run that's in progress, when the alarm is in an ALARM state.
"""
function create_practice_run_configuration(
outcomeAlarms, resourceIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"POST",
"/configuration",
Dict{String,Any}(
"outcomeAlarms" => outcomeAlarms, "resourceIdentifier" => resourceIdentifier
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_practice_run_configuration(
outcomeAlarms,
resourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"POST",
"/configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"outcomeAlarms" => outcomeAlarms,
"resourceIdentifier" => resourceIdentifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_practice_run_configuration(resource_identifier)
delete_practice_run_configuration(resource_identifier, params::Dict{String,<:Any})
Deletes the practice run configuration for a resource. Before you can delete a practice run
configuration for a resource., you must disable zonal autoshift for the resource. Practice
runs must be configured for zonal autoshift to be enabled.
# Arguments
- `resource_identifier`: The identifier for the resource that you want to delete the
practice run configuration for. The identifier is the Amazon Resource Name (ARN) for the
resource.
"""
function delete_practice_run_configuration(
resourceIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"DELETE",
"/configuration/$(resourceIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_practice_run_configuration(
resourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"DELETE",
"/configuration/$(resourceIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_managed_resource(resource_identifier)
get_managed_resource(resource_identifier, params::Dict{String,<:Any})
Get information about a resource that's been registered for zonal shifts with Amazon Route
53 Application Recovery Controller in this Amazon Web Services Region. Resources that are
registered for zonal shifts are managed resources in Route 53 ARC. You can start zonal
shifts and configure zonal autoshift for managed resources. At this time, you can only
start a zonal shift or configure zonal autoshift for Network Load Balancers and Application
Load Balancers with cross-zone load balancing turned off.
# Arguments
- `resource_identifier`: The identifier for the resource to shift away traffic for. The
identifier is the Amazon Resource Name (ARN) for the resource. At this time, supported
resources are Network Load Balancers and Application Load Balancers with cross-zone load
balancing turned off.
"""
function get_managed_resource(
resourceIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"GET",
"/managedresources/$(resourceIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_managed_resource(
resourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"GET",
"/managedresources/$(resourceIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_autoshifts()
list_autoshifts(params::Dict{String,<:Any})
Returns the active autoshifts for a specified resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The number of objects that you want to return with this call.
- `"nextToken"`: Specifies that you want to receive the next page of results. Valid only if
you received a NextToken response in the previous request. If you did, it indicates that
more output is available. Set this parameter to the value provided by the previous call's
NextToken response to request the next page of results.
- `"status"`: The status of the autoshift.
"""
function list_autoshifts(; aws_config::AbstractAWSConfig=global_aws_config())
return arc_zonal_shift(
"GET", "/autoshifts"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_autoshifts(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"GET", "/autoshifts", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_managed_resources()
list_managed_resources(params::Dict{String,<:Any})
Lists all the resources in your Amazon Web Services account in this Amazon Web Services
Region that are managed for zonal shifts in Amazon Route 53 Application Recovery
Controller, and information about them. The information includes the zonal autoshift status
for the resource, as well as the Amazon Resource Name (ARN), the Availability Zones that
each resource is deployed in, and the resource name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The number of objects that you want to return with this call.
- `"nextToken"`: Specifies that you want to receive the next page of results. Valid only if
you received a NextToken response in the previous request. If you did, it indicates that
more output is available. Set this parameter to the value provided by the previous call's
NextToken response to request the next page of results.
"""
function list_managed_resources(; aws_config::AbstractAWSConfig=global_aws_config())
return arc_zonal_shift(
"GET", "/managedresources"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_managed_resources(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"GET",
"/managedresources",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_zonal_shifts()
list_zonal_shifts(params::Dict{String,<:Any})
Lists all active and completed zonal shifts in Amazon Route 53 Application Recovery
Controller in your Amazon Web Services account in this Amazon Web Services Region.
ListZonalShifts returns customer-started zonal shifts, as well as practice run zonal shifts
that Route 53 ARC started on your behalf for zonal autoshift. The ListZonalShifts operation
does not list autoshifts. For more information about listing autoshifts, see
\">ListAutoshifts.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The number of objects that you want to return with this call.
- `"nextToken"`: Specifies that you want to receive the next page of results. Valid only if
you received a NextToken response in the previous request. If you did, it indicates that
more output is available. Set this parameter to the value provided by the previous call's
NextToken response to request the next page of results.
- `"resourceIdentifier"`: The identifier for the resource that you want to list zonal
shifts for. The identifier is the Amazon Resource Name (ARN) for the resource.
- `"status"`: A status for a zonal shift. The Status for a zonal shift can have one of the
following values: ACTIVE: The zonal shift has been started and active. EXPIRED: The
zonal shift has expired (the expiry time was exceeded). CANCELED: The zonal shift was
canceled.
"""
function list_zonal_shifts(; aws_config::AbstractAWSConfig=global_aws_config())
return arc_zonal_shift(
"GET", "/zonalshifts"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_zonal_shifts(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"GET",
"/zonalshifts",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_zonal_shift(away_from, comment, expires_in, resource_identifier)
start_zonal_shift(away_from, comment, expires_in, resource_identifier, params::Dict{String,<:Any})
You start a zonal shift to temporarily move load balancer traffic away from an Availability
Zone in an Amazon Web Services Region, to help your application recover immediately, for
example, from a developer's bad code deployment or from an Amazon Web Services
infrastructure failure in a single Availability Zone. You can start a zonal shift in Route
53 ARC only for managed resources in your Amazon Web Services account in an Amazon Web
Services Region. Resources are automatically registered with Route 53 ARC by Amazon Web
Services services. At this time, you can only start a zonal shift for Network Load
Balancers and Application Load Balancers with cross-zone load balancing turned off. When
you start a zonal shift, traffic for the resource is no longer routed to the Availability
Zone. The zonal shift is created immediately in Route 53 ARC. However, it can take a short
time, typically up to a few minutes, for existing, in-progress connections in the
Availability Zone to complete. For more information, see Zonal shift in the Amazon Route 53
Application Recovery Controller Developer Guide.
# Arguments
- `away_from`: The Availability Zone that traffic is moved away from for a resource when
you start a zonal shift. Until the zonal shift expires or you cancel it, traffic for the
resource is instead moved to other Availability Zones in the Amazon Web Services Region.
- `comment`: A comment that you enter about the zonal shift. Only the latest comment is
retained; no comment history is maintained. A new comment overwrites any existing comment
string.
- `expires_in`: The length of time that you want a zonal shift to be active, which Route 53
ARC converts to an expiry time (expiration time). Zonal shifts are temporary. You can set a
zonal shift to be active initially for up to three days (72 hours). If you want to still
keep traffic away from an Availability Zone, you can update the zonal shift and set a new
expiration. You can also cancel a zonal shift, before it expires, for example, if you're
ready to restore traffic to the Availability Zone. To set a length of time for a zonal
shift to be active, specify a whole number, and then one of the following, with no space:
A lowercase letter m: To specify that the value is in minutes. A lowercase letter h: To
specify that the value is in hours. For example: 20h means the zonal shift expires in 20
hours. 120m means the zonal shift expires in 120 minutes (2 hours).
- `resource_identifier`: The identifier for the resource to shift away traffic for. The
identifier is the Amazon Resource Name (ARN) for the resource. At this time, supported
resources are Network Load Balancers and Application Load Balancers with cross-zone load
balancing turned off.
"""
function start_zonal_shift(
awayFrom,
comment,
expiresIn,
resourceIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"POST",
"/zonalshifts",
Dict{String,Any}(
"awayFrom" => awayFrom,
"comment" => comment,
"expiresIn" => expiresIn,
"resourceIdentifier" => resourceIdentifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_zonal_shift(
awayFrom,
comment,
expiresIn,
resourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"POST",
"/zonalshifts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"awayFrom" => awayFrom,
"comment" => comment,
"expiresIn" => expiresIn,
"resourceIdentifier" => resourceIdentifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_practice_run_configuration(resource_identifier)
update_practice_run_configuration(resource_identifier, params::Dict{String,<:Any})
Update a practice run configuration to change one or more of the following: add, change, or
remove the blocking alarm; change the outcome alarm; or add, change, or remove blocking
dates or time windows.
# Arguments
- `resource_identifier`: The identifier for the resource that you want to update the
practice run configuration for. The identifier is the Amazon Resource Name (ARN) for the
resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"blockedDates"`: Add, change, or remove blocked dates for a practice run in zonal
autoshift. Optionally, you can block practice runs for specific calendar dates. The format
for blocked dates is: YYYY-MM-DD. Keep in mind, when you specify dates, that dates and
times for practice runs are in UTC. Separate multiple blocked dates with spaces. For
example, if you have an application update scheduled to launch on May 1, 2024, and you
don't want practice runs to shift traffic away at that time, you could set a blocked date
for 2024-05-01.
- `"blockedWindows"`: Add, change, or remove windows of days and times for when you can,
optionally, block Route 53 ARC from starting a practice run for a resource. The format for
blocked windows is: DAY:HH:SS-DAY:HH:SS. Keep in mind, when you specify dates, that dates
and times for practice runs are in UTC. Also, be aware of potential time adjustments that
might be required for daylight saving time differences. Separate multiple blocked windows
with spaces. For example, say you run business report summaries three days a week. For this
scenario, you might set the following recurring days and times as blocked windows, for
example: MON-20:30-21:30 WED-20:30-21:30 FRI-20:30-21:30.
- `"blockingAlarms"`: Add, change, or remove the Amazon CloudWatch alarm that you
optionally specify as the blocking alarm for practice runs.
- `"outcomeAlarms"`: Specify a new the Amazon CloudWatch alarm as the outcome alarm for
practice runs.
"""
function update_practice_run_configuration(
resourceIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return arc_zonal_shift(
"PATCH",
"/configuration/$(resourceIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_practice_run_configuration(
resourceIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"PATCH",
"/configuration/$(resourceIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_zonal_autoshift_configuration(resource_identifier, zonal_autoshift_status)
update_zonal_autoshift_configuration(resource_identifier, zonal_autoshift_status, params::Dict{String,<:Any})
You can update the zonal autoshift status for a resource, to enable or disable zonal
autoshift. When zonal autoshift is ENABLED, Amazon Web Services shifts away resource
traffic from an Availability Zone, on your behalf, when Amazon Web Services determines that
there's an issue in the Availability Zone that could potentially affect customers.
# Arguments
- `resource_identifier`: The identifier for the resource that you want to update the zonal
autoshift configuration for. The identifier is the Amazon Resource Name (ARN) for the
resource.
- `zonal_autoshift_status`: The zonal autoshift status for the resource that you want to
update the zonal autoshift configuration for.
"""
function update_zonal_autoshift_configuration(
resourceIdentifier,
zonalAutoshiftStatus;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"PUT",
"/managedresources/$(resourceIdentifier)",
Dict{String,Any}("zonalAutoshiftStatus" => zonalAutoshiftStatus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_zonal_autoshift_configuration(
resourceIdentifier,
zonalAutoshiftStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"PUT",
"/managedresources/$(resourceIdentifier)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("zonalAutoshiftStatus" => zonalAutoshiftStatus),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_zonal_shift(zonal_shift_id)
update_zonal_shift(zonal_shift_id, params::Dict{String,<:Any})
Update an active zonal shift in Amazon Route 53 Application Recovery Controller in your
Amazon Web Services account. You can update a zonal shift to set a new expiration, or edit
or replace the comment for the zonal shift.
# Arguments
- `zonal_shift_id`: The identifier of a zonal shift.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"comment"`: A comment that you enter about the zonal shift. Only the latest comment is
retained; no comment history is maintained. A new comment overwrites any existing comment
string.
- `"expiresIn"`: The length of time that you want a zonal shift to be active, which Route
53 ARC converts to an expiry time (expiration time). Zonal shifts are temporary. You can
set a zonal shift to be active initially for up to three days (72 hours). If you want to
still keep traffic away from an Availability Zone, you can update the zonal shift and set a
new expiration. You can also cancel a zonal shift, before it expires, for example, if
you're ready to restore traffic to the Availability Zone. To set a length of time for a
zonal shift to be active, specify a whole number, and then one of the following, with no
space: A lowercase letter m: To specify that the value is in minutes. A lowercase
letter h: To specify that the value is in hours. For example: 20h means the zonal shift
expires in 20 hours. 120m means the zonal shift expires in 120 minutes (2 hours).
"""
function update_zonal_shift(zonalShiftId; aws_config::AbstractAWSConfig=global_aws_config())
return arc_zonal_shift(
"PATCH",
"/zonalshifts/$(zonalShiftId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_zonal_shift(
zonalShiftId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return arc_zonal_shift(
"PATCH",
"/zonalshifts/$(zonalShiftId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 5884 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: artifact
using AWS.Compat
using AWS.UUIDs
"""
get_account_settings()
get_account_settings(params::Dict{String,<:Any})
Get the account settings for Artifact.
"""
function get_account_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"GET",
"/v1/account-settings/get";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_account_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return artifact(
"GET",
"/v1/account-settings/get",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_report(report_id, term_token)
get_report(report_id, term_token, params::Dict{String,<:Any})
Get the content for a single report.
# Arguments
- `report_id`: Unique resource ID for the report resource.
- `term_token`: Unique download token provided by GetTermForReport API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"reportVersion"`: Version for the report resource.
"""
function get_report(reportId, termToken; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"GET",
"/v1/report/get",
Dict{String,Any}("reportId" => reportId, "termToken" => termToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_report(
reportId,
termToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return artifact(
"GET",
"/v1/report/get",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("reportId" => reportId, "termToken" => termToken),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_report_metadata(report_id)
get_report_metadata(report_id, params::Dict{String,<:Any})
Get the metadata for a single report.
# Arguments
- `report_id`: Unique resource ID for the report resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"reportVersion"`: Version for the report resource.
"""
function get_report_metadata(reportId; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"GET",
"/v1/report/getMetadata",
Dict{String,Any}("reportId" => reportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_report_metadata(
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return artifact(
"GET",
"/v1/report/getMetadata",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportId" => reportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_term_for_report(report_id)
get_term_for_report(report_id, params::Dict{String,<:Any})
Get the Term content associated with a single report.
# Arguments
- `report_id`: Unique resource ID for the report resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"reportVersion"`: Version for the report resource.
"""
function get_term_for_report(reportId; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"GET",
"/v1/report/getTermForReport",
Dict{String,Any}("reportId" => reportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_term_for_report(
reportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return artifact(
"GET",
"/v1/report/getTermForReport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportId" => reportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_reports()
list_reports(params::Dict{String,<:Any})
List available reports.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Maximum number of resources to return in the paginated response.
- `"nextToken"`: Pagination token to request the next page of resources.
"""
function list_reports(; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"GET", "/v1/report/list"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_reports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return artifact(
"GET",
"/v1/report/list",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_account_settings()
put_account_settings(params::Dict{String,<:Any})
Put the account settings for Artifact.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"notificationSubscriptionStatus"`: Desired notification subscription status.
"""
function put_account_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return artifact(
"PUT",
"/v1/account-settings/put";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_account_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return artifact(
"PUT",
"/v1/account-settings/put",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 100313 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: athena
using AWS.Compat
using AWS.UUIDs
"""
batch_get_named_query(named_query_ids)
batch_get_named_query(named_query_ids, params::Dict{String,<:Any})
Returns the details of a single named query or a list of up to 50 queries, which you
provide as an array of query ID strings. Requires you to have access to the workgroup in
which the queries were saved. Use ListNamedQueriesInput to get the list of named query IDs
in the specified workgroup. If information could not be retrieved for a submitted query ID,
information about the query ID submitted is listed under UnprocessedNamedQueryId. Named
queries differ from executed queries. Use BatchGetQueryExecutionInput to get details about
each unique query execution, and ListQueryExecutionsInput to get a list of query execution
IDs.
# Arguments
- `named_query_ids`: An array of query IDs.
"""
function batch_get_named_query(
NamedQueryIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"BatchGetNamedQuery",
Dict{String,Any}("NamedQueryIds" => NamedQueryIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_named_query(
NamedQueryIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"BatchGetNamedQuery",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NamedQueryIds" => NamedQueryIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_prepared_statement(prepared_statement_names, work_group)
batch_get_prepared_statement(prepared_statement_names, work_group, params::Dict{String,<:Any})
Returns the details of a single prepared statement or a list of up to 256 prepared
statements for the array of prepared statement names that you provide. Requires you to have
access to the workgroup to which the prepared statements belong. If a prepared statement
cannot be retrieved for the name specified, the statement is listed in
UnprocessedPreparedStatementNames.
# Arguments
- `prepared_statement_names`: A list of prepared statement names to return.
- `work_group`: The name of the workgroup to which the prepared statements belong.
"""
function batch_get_prepared_statement(
PreparedStatementNames, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"BatchGetPreparedStatement",
Dict{String,Any}(
"PreparedStatementNames" => PreparedStatementNames, "WorkGroup" => WorkGroup
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_prepared_statement(
PreparedStatementNames,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"BatchGetPreparedStatement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PreparedStatementNames" => PreparedStatementNames,
"WorkGroup" => WorkGroup,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_query_execution(query_execution_ids)
batch_get_query_execution(query_execution_ids, params::Dict{String,<:Any})
Returns the details of a single query execution or a list of up to 50 query executions,
which you provide as an array of query execution ID strings. Requires you to have access to
the workgroup in which the queries ran. To get a list of query execution IDs, use
ListQueryExecutionsInputWorkGroup. Query executions differ from named (saved) queries. Use
BatchGetNamedQueryInput to get details about named queries.
# Arguments
- `query_execution_ids`: An array of query execution IDs.
"""
function batch_get_query_execution(
QueryExecutionIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"BatchGetQueryExecution",
Dict{String,Any}("QueryExecutionIds" => QueryExecutionIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_query_execution(
QueryExecutionIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"BatchGetQueryExecution",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("QueryExecutionIds" => QueryExecutionIds), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_capacity_reservation(name)
cancel_capacity_reservation(name, params::Dict{String,<:Any})
Cancels the capacity reservation with the specified name. Cancelled reservations remain in
your account and will be deleted 45 days after cancellation. During the 45 days, you cannot
re-purpose or reuse a reservation that has been cancelled, but you can refer to its tags
and view it for historical reference.
# Arguments
- `name`: The name of the capacity reservation to cancel.
"""
function cancel_capacity_reservation(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CancelCapacityReservation",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_capacity_reservation(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CancelCapacityReservation",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_capacity_reservation(name, target_dpus)
create_capacity_reservation(name, target_dpus, params::Dict{String,<:Any})
Creates a capacity reservation with the specified name and number of requested data
processing units.
# Arguments
- `name`: The name of the capacity reservation to create.
- `target_dpus`: The number of requested data processing units.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tags for the capacity reservation.
"""
function create_capacity_reservation(
Name, TargetDpus; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CreateCapacityReservation",
Dict{String,Any}("Name" => Name, "TargetDpus" => TargetDpus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_capacity_reservation(
Name,
TargetDpus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreateCapacityReservation",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "TargetDpus" => TargetDpus), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_data_catalog(name, type)
create_data_catalog(name, type, params::Dict{String,<:Any})
Creates (registers) a data catalog with the specified name and properties. Catalogs created
are visible to all users of the same Amazon Web Services account.
# Arguments
- `name`: The name of the data catalog to create. The catalog name must be unique for the
Amazon Web Services account and can use a maximum of 127 alphanumeric, underscore, at sign,
or hyphen characters. The remainder of the length constraint of 256 is reserved for use by
Athena.
- `type`: The type of data catalog to create: LAMBDA for a federated catalog, HIVE for an
external hive metastore, or GLUE for an Glue Data Catalog.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the data catalog to be created.
- `"Parameters"`: Specifies the Lambda function or functions to use for creating the data
catalog. This is a mapping whose values depend on the catalog type. For the HIVE data
catalog type, use the following syntax. The metadata-function parameter is required. The
sdk-version parameter is optional and defaults to the currently supported version.
metadata-function=lambda_arn, sdk-version=version_number For the LAMBDA data catalog
type, use one of the following sets of required parameters, but not both. If you have one
Lambda function that processes metadata and another for reading the actual data, use the
following syntax. Both parameters are required. metadata-function=lambda_arn,
record-function=lambda_arn If you have a composite Lambda function that processes both
metadata and data, use the following syntax to specify your Lambda function.
function=lambda_arn The GLUE type takes a catalog ID parameter and is required. The
catalog_id is the account ID of the Amazon Web Services account to which the Glue Data
Catalog belongs. catalog-id=catalog_id The GLUE data catalog type also applies to the
default AwsDataCatalog that already exists in your account, of which you can have only one
and cannot modify.
- `"Tags"`: A list of comma separated tags to add to the data catalog that is created.
"""
function create_data_catalog(Name, Type; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"CreateDataCatalog",
Dict{String,Any}("Name" => Name, "Type" => Type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_data_catalog(
Name,
Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreateDataCatalog",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Name" => Name, "Type" => Type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_named_query(database, name, query_string)
create_named_query(database, name, query_string, params::Dict{String,<:Any})
Creates a named query in the specified workgroup. Requires that you have access to the
workgroup.
# Arguments
- `database`: The database to which the query belongs.
- `name`: The query name.
- `query_string`: The contents of the query with all query statements.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the query is idempotent (executes only once). If another CreateNamedQuery request is
received, the same response is returned and another query is not created. If a parameter
has changed, for example, the QueryString, an error is returned. This token is listed as
not required because Amazon Web Services SDKs (for example the Amazon Web Services SDK for
Java) auto-generate the token for users. If you are not using the Amazon Web Services SDK
or the Amazon Web Services CLI, you must provide this token or the action will fail.
- `"Description"`: The query description.
- `"WorkGroup"`: The name of the workgroup in which the named query is being created.
"""
function create_named_query(
Database, Name, QueryString; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CreateNamedQuery",
Dict{String,Any}(
"Database" => Database,
"Name" => Name,
"QueryString" => QueryString,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_named_query(
Database,
Name,
QueryString,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreateNamedQuery",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Database" => Database,
"Name" => Name,
"QueryString" => QueryString,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_notebook(name, work_group)
create_notebook(name, work_group, params::Dict{String,<:Any})
Creates an empty ipynb file in the specified Apache Spark enabled workgroup. Throws an
error if a file in the workgroup with the same name already exists.
# Arguments
- `name`: The name of the ipynb file to be created in the Spark workgroup, without the
.ipynb extension.
- `work_group`: The name of the Spark enabled workgroup in which the notebook will be
created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the notebook is idempotent (executes only once). This token is listed as not
required because Amazon Web Services SDKs (for example the Amazon Web Services SDK for
Java) auto-generate the token for you. If you are not using the Amazon Web Services SDK or
the Amazon Web Services CLI, you must provide this token or the action will fail.
"""
function create_notebook(Name, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"CreateNotebook",
Dict{String,Any}("Name" => Name, "WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_notebook(
Name,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreateNotebook",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "WorkGroup" => WorkGroup), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_prepared_statement(query_statement, statement_name, work_group)
create_prepared_statement(query_statement, statement_name, work_group, params::Dict{String,<:Any})
Creates a prepared statement for use with SQL queries in Athena.
# Arguments
- `query_statement`: The query string for the prepared statement.
- `statement_name`: The name of the prepared statement.
- `work_group`: The name of the workgroup to which the prepared statement belongs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the prepared statement.
"""
function create_prepared_statement(
QueryStatement,
StatementName,
WorkGroup;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreatePreparedStatement",
Dict{String,Any}(
"QueryStatement" => QueryStatement,
"StatementName" => StatementName,
"WorkGroup" => WorkGroup,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_prepared_statement(
QueryStatement,
StatementName,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreatePreparedStatement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"QueryStatement" => QueryStatement,
"StatementName" => StatementName,
"WorkGroup" => WorkGroup,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_presigned_notebook_url(session_id)
create_presigned_notebook_url(session_id, params::Dict{String,<:Any})
Gets an authentication token and the URL at which the notebook can be accessed. During
programmatic access, CreatePresignedNotebookUrl must be called every 10 minutes to refresh
the authentication token. For information about granting programmatic access, see Grant
programmatic access.
# Arguments
- `session_id`: The session ID.
"""
function create_presigned_notebook_url(
SessionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CreatePresignedNotebookUrl",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_presigned_notebook_url(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"CreatePresignedNotebookUrl",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_work_group(name)
create_work_group(name, params::Dict{String,<:Any})
Creates a workgroup with the specified name. A workgroup can be an Apache Spark enabled
workgroup or an Athena SQL workgroup.
# Arguments
- `name`: The workgroup name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Configuration"`: Contains configuration information for creating an Athena SQL
workgroup or Spark enabled Athena workgroup. Athena SQL workgroup configuration includes
the location in Amazon S3 where query and calculation results are stored, the encryption
configuration, if any, used for encrypting query results, whether the Amazon CloudWatch
Metrics are enabled for the workgroup, the limit for the amount of bytes scanned (cutoff)
per query, if it is specified, and whether workgroup's settings (specified with
EnforceWorkGroupConfiguration) in the WorkGroupConfiguration override client-side settings.
See WorkGroupConfigurationEnforceWorkGroupConfiguration.
- `"Description"`: The workgroup description.
- `"Tags"`: A list of comma separated tags to add to the workgroup that is created.
"""
function create_work_group(Name; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"CreateWorkGroup",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_work_group(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"CreateWorkGroup",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_capacity_reservation(name)
delete_capacity_reservation(name, params::Dict{String,<:Any})
Deletes a cancelled capacity reservation. A reservation must be cancelled before it can be
deleted. A deleted reservation is immediately removed from your account and can no longer
be referenced, including by its ARN. A deleted reservation cannot be called by
GetCapacityReservation, and deleted reservations do not appear in the output of
ListCapacityReservations.
# Arguments
- `name`: The name of the capacity reservation to delete.
"""
function delete_capacity_reservation(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"DeleteCapacityReservation",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_capacity_reservation(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"DeleteCapacityReservation",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_data_catalog(name)
delete_data_catalog(name, params::Dict{String,<:Any})
Deletes a data catalog.
# Arguments
- `name`: The name of the data catalog to delete.
"""
function delete_data_catalog(Name; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"DeleteDataCatalog",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_data_catalog(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"DeleteDataCatalog",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_named_query(named_query_id)
delete_named_query(named_query_id, params::Dict{String,<:Any})
Deletes the named query if you have access to the workgroup in which the query was saved.
# Arguments
- `named_query_id`: The unique ID of the query to delete.
"""
function delete_named_query(NamedQueryId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"DeleteNamedQuery",
Dict{String,Any}("NamedQueryId" => NamedQueryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_named_query(
NamedQueryId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"DeleteNamedQuery",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NamedQueryId" => NamedQueryId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_notebook(notebook_id)
delete_notebook(notebook_id, params::Dict{String,<:Any})
Deletes the specified notebook.
# Arguments
- `notebook_id`: The ID of the notebook to delete.
"""
function delete_notebook(NotebookId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"DeleteNotebook",
Dict{String,Any}("NotebookId" => NotebookId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_notebook(
NotebookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"DeleteNotebook",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NotebookId" => NotebookId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_prepared_statement(statement_name, work_group)
delete_prepared_statement(statement_name, work_group, params::Dict{String,<:Any})
Deletes the prepared statement with the specified name from the specified workgroup.
# Arguments
- `statement_name`: The name of the prepared statement to delete.
- `work_group`: The workgroup to which the statement to be deleted belongs.
"""
function delete_prepared_statement(
StatementName, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"DeletePreparedStatement",
Dict{String,Any}("StatementName" => StatementName, "WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_prepared_statement(
StatementName,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"DeletePreparedStatement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StatementName" => StatementName, "WorkGroup" => WorkGroup
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_work_group(work_group)
delete_work_group(work_group, params::Dict{String,<:Any})
Deletes the workgroup with the specified name. The primary workgroup cannot be deleted.
# Arguments
- `work_group`: The unique name of the workgroup to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RecursiveDeleteOption"`: The option to delete the workgroup and its contents even if
the workgroup contains any named queries, query executions, or notebooks.
"""
function delete_work_group(WorkGroup; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"DeleteWorkGroup",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_work_group(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"DeleteWorkGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_notebook(notebook_id)
export_notebook(notebook_id, params::Dict{String,<:Any})
Exports the specified notebook and its metadata.
# Arguments
- `notebook_id`: The ID of the notebook to export.
"""
function export_notebook(NotebookId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ExportNotebook",
Dict{String,Any}("NotebookId" => NotebookId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_notebook(
NotebookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ExportNotebook",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NotebookId" => NotebookId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_calculation_execution(calculation_execution_id)
get_calculation_execution(calculation_execution_id, params::Dict{String,<:Any})
Describes a previously submitted calculation execution.
# Arguments
- `calculation_execution_id`: The calculation execution UUID.
"""
function get_calculation_execution(
CalculationExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetCalculationExecution",
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_calculation_execution(
CalculationExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetCalculationExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_calculation_execution_code(calculation_execution_id)
get_calculation_execution_code(calculation_execution_id, params::Dict{String,<:Any})
Retrieves the unencrypted code that was executed for the calculation.
# Arguments
- `calculation_execution_id`: The calculation execution UUID.
"""
function get_calculation_execution_code(
CalculationExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetCalculationExecutionCode",
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_calculation_execution_code(
CalculationExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetCalculationExecutionCode",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_calculation_execution_status(calculation_execution_id)
get_calculation_execution_status(calculation_execution_id, params::Dict{String,<:Any})
Gets the status of a current calculation.
# Arguments
- `calculation_execution_id`: The calculation execution UUID.
"""
function get_calculation_execution_status(
CalculationExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetCalculationExecutionStatus",
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_calculation_execution_status(
CalculationExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetCalculationExecutionStatus",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_capacity_assignment_configuration(capacity_reservation_name)
get_capacity_assignment_configuration(capacity_reservation_name, params::Dict{String,<:Any})
Gets the capacity assignment configuration for a capacity reservation, if one exists.
# Arguments
- `capacity_reservation_name`: The name of the capacity reservation to retrieve the
capacity assignment configuration for.
"""
function get_capacity_assignment_configuration(
CapacityReservationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetCapacityAssignmentConfiguration",
Dict{String,Any}("CapacityReservationName" => CapacityReservationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_capacity_assignment_configuration(
CapacityReservationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetCapacityAssignmentConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CapacityReservationName" => CapacityReservationName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_capacity_reservation(name)
get_capacity_reservation(name, params::Dict{String,<:Any})
Returns information about the capacity reservation with the specified name.
# Arguments
- `name`: The name of the capacity reservation.
"""
function get_capacity_reservation(Name; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetCapacityReservation",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_capacity_reservation(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetCapacityReservation",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_data_catalog(name)
get_data_catalog(name, params::Dict{String,<:Any})
Returns the specified data catalog.
# Arguments
- `name`: The name of the data catalog to return.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"WorkGroup"`: The name of the workgroup. Required if making an IAM Identity Center
request.
"""
function get_data_catalog(Name; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetDataCatalog",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_catalog(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetDataCatalog",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_database(catalog_name, database_name)
get_database(catalog_name, database_name, params::Dict{String,<:Any})
Returns a database object for the specified database and data catalog.
# Arguments
- `catalog_name`: The name of the data catalog that contains the database to return.
- `database_name`: The name of the database to return.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"WorkGroup"`: The name of the workgroup for which the metadata is being fetched.
Required if requesting an IAM Identity Center enabled Glue Data Catalog.
"""
function get_database(
CatalogName, DatabaseName; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetDatabase",
Dict{String,Any}("CatalogName" => CatalogName, "DatabaseName" => DatabaseName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_database(
CatalogName,
DatabaseName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetDatabase",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CatalogName" => CatalogName, "DatabaseName" => DatabaseName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_named_query(named_query_id)
get_named_query(named_query_id, params::Dict{String,<:Any})
Returns information about a single query. Requires that you have access to the workgroup in
which the query was saved.
# Arguments
- `named_query_id`: The unique ID of the query. Use ListNamedQueries to get query IDs.
"""
function get_named_query(NamedQueryId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetNamedQuery",
Dict{String,Any}("NamedQueryId" => NamedQueryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_named_query(
NamedQueryId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetNamedQuery",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NamedQueryId" => NamedQueryId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_notebook_metadata(notebook_id)
get_notebook_metadata(notebook_id, params::Dict{String,<:Any})
Retrieves notebook metadata for the specified notebook ID.
# Arguments
- `notebook_id`: The ID of the notebook whose metadata is to be retrieved.
"""
function get_notebook_metadata(
NotebookId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetNotebookMetadata",
Dict{String,Any}("NotebookId" => NotebookId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_notebook_metadata(
NotebookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetNotebookMetadata",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NotebookId" => NotebookId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_prepared_statement(statement_name, work_group)
get_prepared_statement(statement_name, work_group, params::Dict{String,<:Any})
Retrieves the prepared statement with the specified name from the specified workgroup.
# Arguments
- `statement_name`: The name of the prepared statement to retrieve.
- `work_group`: The workgroup to which the statement to be retrieved belongs.
"""
function get_prepared_statement(
StatementName, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetPreparedStatement",
Dict{String,Any}("StatementName" => StatementName, "WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_prepared_statement(
StatementName,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetPreparedStatement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StatementName" => StatementName, "WorkGroup" => WorkGroup
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_query_execution(query_execution_id)
get_query_execution(query_execution_id, params::Dict{String,<:Any})
Returns information about a single execution of a query if you have access to the workgroup
in which the query ran. Each time a query executes, information about the query execution
is saved with a unique ID.
# Arguments
- `query_execution_id`: The unique ID of the query execution.
"""
function get_query_execution(
QueryExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetQueryExecution",
Dict{String,Any}("QueryExecutionId" => QueryExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_query_execution(
QueryExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetQueryExecution",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("QueryExecutionId" => QueryExecutionId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_query_results(query_execution_id)
get_query_results(query_execution_id, params::Dict{String,<:Any})
Streams the results of a single query execution specified by QueryExecutionId from the
Athena query results location in Amazon S3. For more information, see Working with query
results, recent queries, and output files in the Amazon Athena User Guide. This request
does not execute the query but returns results. Use StartQueryExecution to run a query. To
stream query results successfully, the IAM principal with permission to call
GetQueryResults also must have permissions to the Amazon S3 GetObject action for the Athena
query results location. IAM principals with permission to the Amazon S3 GetObject action
for the query results location are able to retrieve query results from Amazon S3 even if
permission to the GetQueryResults action is denied. To restrict user or role access, ensure
that Amazon S3 permissions to the Athena query location are denied.
# Arguments
- `query_execution_id`: The unique ID of the query execution.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results (rows) to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function get_query_results(
QueryExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetQueryResults",
Dict{String,Any}("QueryExecutionId" => QueryExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_query_results(
QueryExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetQueryResults",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("QueryExecutionId" => QueryExecutionId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_query_runtime_statistics(query_execution_id)
get_query_runtime_statistics(query_execution_id, params::Dict{String,<:Any})
Returns query execution runtime statistics related to a single execution of a query if you
have access to the workgroup in which the query ran. Statistics from the Timeline section
of the response object are available as soon as QueryExecutionStatusState is in a SUCCEEDED
or FAILED state. The remaining non-timeline statistics in the response (like stage-level
input and output row count and data size) are updated asynchronously and may not be
available immediately after a query completes. The non-timeline statistics are also not
included when a query has row-level filters defined in Lake Formation.
# Arguments
- `query_execution_id`: The unique ID of the query execution.
"""
function get_query_runtime_statistics(
QueryExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetQueryRuntimeStatistics",
Dict{String,Any}("QueryExecutionId" => QueryExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_query_runtime_statistics(
QueryExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetQueryRuntimeStatistics",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("QueryExecutionId" => QueryExecutionId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_session(session_id)
get_session(session_id, params::Dict{String,<:Any})
Gets the full details of a previously created session, including the session status and
configuration.
# Arguments
- `session_id`: The session ID.
"""
function get_session(SessionId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetSession",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_session(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetSession",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_session_status(session_id)
get_session_status(session_id, params::Dict{String,<:Any})
Gets the current status of a session.
# Arguments
- `session_id`: The session ID.
"""
function get_session_status(SessionId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetSessionStatus",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_session_status(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetSessionStatus",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_table_metadata(catalog_name, database_name, table_name)
get_table_metadata(catalog_name, database_name, table_name, params::Dict{String,<:Any})
Returns table metadata for the specified catalog, database, and table.
# Arguments
- `catalog_name`: The name of the data catalog that contains the database and table
metadata to return.
- `database_name`: The name of the database that contains the table metadata to return.
- `table_name`: The name of the table for which metadata is returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"WorkGroup"`: The name of the workgroup for which the metadata is being fetched.
Required if requesting an IAM Identity Center enabled Glue Data Catalog.
"""
function get_table_metadata(
CatalogName, DatabaseName, TableName; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"GetTableMetadata",
Dict{String,Any}(
"CatalogName" => CatalogName,
"DatabaseName" => DatabaseName,
"TableName" => TableName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_table_metadata(
CatalogName,
DatabaseName,
TableName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetTableMetadata",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CatalogName" => CatalogName,
"DatabaseName" => DatabaseName,
"TableName" => TableName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_work_group(work_group)
get_work_group(work_group, params::Dict{String,<:Any})
Returns information about the workgroup with the specified name.
# Arguments
- `work_group`: The name of the workgroup.
"""
function get_work_group(WorkGroup; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"GetWorkGroup",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_work_group(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"GetWorkGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_notebook(name, type, work_group)
import_notebook(name, type, work_group, params::Dict{String,<:Any})
Imports a single ipynb file to a Spark enabled workgroup. To import the notebook, the
request must specify a value for either Payload or NoteBookS3LocationUri. If neither is
specified or both are specified, an InvalidRequestException occurs. The maximum file size
that can be imported is 10 megabytes. If an ipynb file with the same name already exists in
the workgroup, throws an error.
# Arguments
- `name`: The name of the notebook to import.
- `type`: The notebook content type. Currently, the only valid type is IPYNB.
- `work_group`: The name of the Spark enabled workgroup to import the notebook to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
import the notebook is idempotent (executes only once). This token is listed as not
required because Amazon Web Services SDKs (for example the Amazon Web Services SDK for
Java) auto-generate the token for you. If you are not using the Amazon Web Services SDK or
the Amazon Web Services CLI, you must provide this token or the action will fail.
- `"NotebookS3LocationUri"`: A URI that specifies the Amazon S3 location of a notebook file
in ipynb format.
- `"Payload"`: The notebook content to be imported. The payload must be in ipynb format.
"""
function import_notebook(
Name, Type, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ImportNotebook",
Dict{String,Any}("Name" => Name, "Type" => Type, "WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_notebook(
Name,
Type,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ImportNotebook",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "Type" => Type, "WorkGroup" => WorkGroup),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_application_dpusizes()
list_application_dpusizes(params::Dict{String,<:Any})
Returns the supported DPU sizes for the supported application runtimes (for example, Athena
notebook version 1).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Specifies the maximum number of results to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated.
"""
function list_application_dpusizes(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListApplicationDPUSizes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_application_dpusizes(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListApplicationDPUSizes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_calculation_executions(session_id)
list_calculation_executions(session_id, params::Dict{String,<:Any})
Lists the calculations that have been submitted to a session in descending order. Newer
calculations are listed first; older calculations are listed later.
# Arguments
- `session_id`: The session ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of calculation executions to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"StateFilter"`: A filter for a specific calculation execution state. A description of
each state follows. CREATING - The calculation is in the process of being created.
CREATED - The calculation has been created and is ready to run. QUEUED - The calculation
has been queued for processing. RUNNING - The calculation is running. CANCELING - A
request to cancel the calculation has been received and the system is working to stop it.
CANCELED - The calculation is no longer running as the result of a cancel request.
COMPLETED - The calculation has completed without error. FAILED - The calculation failed
and is no longer running.
"""
function list_calculation_executions(
SessionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListCalculationExecutions",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_calculation_executions(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListCalculationExecutions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_capacity_reservations()
list_capacity_reservations(params::Dict{String,<:Any})
Lists the capacity reservations for the current account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Specifies the maximum number of results to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated.
"""
function list_capacity_reservations(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListCapacityReservations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_capacity_reservations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListCapacityReservations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_data_catalogs()
list_data_catalogs(params::Dict{String,<:Any})
Lists the data catalogs in the current Amazon Web Services account. In the Athena console,
data catalogs are listed as \"data sources\" on the Data sources page under the Data source
name column.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Specifies the maximum number of data catalogs to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"WorkGroup"`: The name of the workgroup. Required if making an IAM Identity Center
request.
"""
function list_data_catalogs(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListDataCatalogs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_data_catalogs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListDataCatalogs", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_databases(catalog_name)
list_databases(catalog_name, params::Dict{String,<:Any})
Lists the databases in the specified data catalog.
# Arguments
- `catalog_name`: The name of the data catalog that contains the databases to return.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Specifies the maximum number of results to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"WorkGroup"`: The name of the workgroup for which the metadata is being fetched.
Required if requesting an IAM Identity Center enabled Glue Data Catalog.
"""
function list_databases(CatalogName; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListDatabases",
Dict{String,Any}("CatalogName" => CatalogName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_databases(
CatalogName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListDatabases",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CatalogName" => CatalogName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_engine_versions()
list_engine_versions(params::Dict{String,<:Any})
Returns a list of engine versions that are available to choose from, including the Auto
option.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of engine versions to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function list_engine_versions(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListEngineVersions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_engine_versions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListEngineVersions", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_executors(session_id)
list_executors(session_id, params::Dict{String,<:Any})
Lists, in descending order, the executors that joined a session. Newer executors are listed
first; older executors are listed later. The result can be optionally filtered by state.
# Arguments
- `session_id`: The session ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExecutorStateFilter"`: A filter for a specific executor state. A description of each
state follows. CREATING - The executor is being started, including acquiring resources.
CREATED - The executor has been started. REGISTERED - The executor has been registered.
TERMINATING - The executor is in the process of shutting down. TERMINATED - The executor
is no longer running. FAILED - Due to a failure, the executor is no longer running.
- `"MaxResults"`: The maximum number of executors to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function list_executors(SessionId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListExecutors",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_executors(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListExecutors",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_named_queries()
list_named_queries(params::Dict{String,<:Any})
Provides a list of available query IDs only for queries saved in the specified workgroup.
Requires that you have access to the specified workgroup. If a workgroup is not specified,
lists the saved queries for the primary workgroup.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of queries to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"WorkGroup"`: The name of the workgroup from which the named queries are being returned.
If a workgroup is not specified, the saved queries for the primary workgroup are returned.
"""
function list_named_queries(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListNamedQueries"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_named_queries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListNamedQueries", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_notebook_metadata(work_group)
list_notebook_metadata(work_group, params::Dict{String,<:Any})
Displays the notebook files for the specified workgroup in paginated format.
# Arguments
- `work_group`: The name of the Spark enabled workgroup to retrieve notebook metadata for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: Search filter string.
- `"MaxResults"`: Specifies the maximum number of results to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated.
"""
function list_notebook_metadata(
WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListNotebookMetadata",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_notebook_metadata(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListNotebookMetadata",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_notebook_sessions(notebook_id)
list_notebook_sessions(notebook_id, params::Dict{String,<:Any})
Lists, in descending order, the sessions that have been created in a notebook that are in
an active state like CREATING, CREATED, IDLE or BUSY. Newer sessions are listed first;
older sessions are listed later.
# Arguments
- `notebook_id`: The ID of the notebook to list sessions for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of notebook sessions to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function list_notebook_sessions(
NotebookId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListNotebookSessions",
Dict{String,Any}("NotebookId" => NotebookId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_notebook_sessions(
NotebookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListNotebookSessions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NotebookId" => NotebookId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_prepared_statements(work_group)
list_prepared_statements(work_group, params::Dict{String,<:Any})
Lists the prepared statements in the specified workgroup.
# Arguments
- `work_group`: The workgroup to list the prepared statements for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function list_prepared_statements(
WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListPreparedStatements",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_prepared_statements(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListPreparedStatements",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_query_executions()
list_query_executions(params::Dict{String,<:Any})
Provides a list of available query execution IDs for the queries in the specified
workgroup. Athena keeps a query history for 45 days. If a workgroup is not specified,
returns a list of query execution IDs for the primary workgroup. Requires you to have
access to the workgroup in which the queries ran.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of query executions to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"WorkGroup"`: The name of the workgroup from which queries are being returned. If a
workgroup is not specified, a list of available query execution IDs for the queries in the
primary workgroup is returned.
"""
function list_query_executions(; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListQueryExecutions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_query_executions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListQueryExecutions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sessions(work_group)
list_sessions(work_group, params::Dict{String,<:Any})
Lists the sessions in a workgroup that are in an active state like CREATING, CREATED, IDLE,
or BUSY. Newer sessions are listed first; older sessions are listed later.
# Arguments
- `work_group`: The workgroup to which the session belongs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of sessions to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"StateFilter"`: A filter for a specific session state. A description of each state
follows. CREATING - The session is being started, including acquiring resources. CREATED
- The session has been started. IDLE - The session is able to accept a calculation. BUSY
- The session is processing another task and is unable to accept a calculation.
TERMINATING - The session is in the process of shutting down. TERMINATED - The session and
its resources are no longer running. DEGRADED - The session has no healthy coordinators.
FAILED - Due to a failure, the session and its resources are no longer running.
"""
function list_sessions(WorkGroup; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"ListSessions",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sessions(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListSessions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_table_metadata(catalog_name, database_name)
list_table_metadata(catalog_name, database_name, params::Dict{String,<:Any})
Lists the metadata for the tables in the specified data catalog database.
# Arguments
- `catalog_name`: The name of the data catalog for which table metadata should be returned.
- `database_name`: The name of the database for which table metadata should be returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Expression"`: A regex filter that pattern-matches table names. If no expression is
supplied, metadata for all tables are listed.
- `"MaxResults"`: Specifies the maximum number of results to return.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
- `"WorkGroup"`: The name of the workgroup for which the metadata is being fetched.
Required if requesting an IAM Identity Center enabled Glue Data Catalog.
"""
function list_table_metadata(
CatalogName, DatabaseName; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListTableMetadata",
Dict{String,Any}("CatalogName" => CatalogName, "DatabaseName" => DatabaseName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_table_metadata(
CatalogName,
DatabaseName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListTableMetadata",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CatalogName" => CatalogName, "DatabaseName" => DatabaseName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists the tags associated with an Athena resource.
# Arguments
- `resource_arn`: Lists the tags for the resource with the specified ARN.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to be returned per request that lists the
tags for the resource.
- `"NextToken"`: The token for the next set of results, or null if there are no additional
results for this request, where the request lists the tags for the resource with the
specified ARN.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_work_groups()
list_work_groups(params::Dict{String,<:Any})
Lists available workgroups for the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of workgroups to return in this request.
- `"NextToken"`: A token generated by the Athena service that specifies where to continue
pagination if a previous request was truncated. To obtain the next set of pages, pass in
the NextToken from the response object of the previous page call.
"""
function list_work_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return athena("ListWorkGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_work_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"ListWorkGroups", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_capacity_assignment_configuration(capacity_assignments, capacity_reservation_name)
put_capacity_assignment_configuration(capacity_assignments, capacity_reservation_name, params::Dict{String,<:Any})
Puts a new capacity assignment configuration for a specified capacity reservation. If a
capacity assignment configuration already exists for the capacity reservation, replaces the
existing capacity assignment configuration.
# Arguments
- `capacity_assignments`: The list of assignments for the capacity assignment configuration.
- `capacity_reservation_name`: The name of the capacity reservation to put a capacity
assignment configuration for.
"""
function put_capacity_assignment_configuration(
CapacityAssignments,
CapacityReservationName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"PutCapacityAssignmentConfiguration",
Dict{String,Any}(
"CapacityAssignments" => CapacityAssignments,
"CapacityReservationName" => CapacityReservationName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_capacity_assignment_configuration(
CapacityAssignments,
CapacityReservationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"PutCapacityAssignmentConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CapacityAssignments" => CapacityAssignments,
"CapacityReservationName" => CapacityReservationName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_calculation_execution(session_id)
start_calculation_execution(session_id, params::Dict{String,<:Any})
Submits calculations for execution within a session. You can supply the code to run as an
inline code block within the request. The request syntax requires the
StartCalculationExecutionRequestCodeBlock parameter or the
CalculationConfigurationCodeBlock parameter, but not both. Because
CalculationConfigurationCodeBlock is deprecated, use the
StartCalculationExecutionRequestCodeBlock parameter instead.
# Arguments
- `session_id`: The session ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CalculationConfiguration"`: Contains configuration information for the calculation.
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the calculation is idempotent (executes only once). If another
StartCalculationExecutionRequest is received, the same response is returned and another
calculation is not created. If a parameter has changed, an error is returned. This token
is listed as not required because Amazon Web Services SDKs (for example the Amazon Web
Services SDK for Java) auto-generate the token for users. If you are not using the Amazon
Web Services SDK or the Amazon Web Services CLI, you must provide this token or the action
will fail.
- `"CodeBlock"`: A string that contains the code of the calculation. Use this parameter
instead of CalculationConfigurationCodeBlock, which is deprecated.
- `"Description"`: A description of the calculation.
"""
function start_calculation_execution(
SessionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"StartCalculationExecution",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_calculation_execution(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"StartCalculationExecution",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_query_execution(query_string)
start_query_execution(query_string, params::Dict{String,<:Any})
Runs the SQL query statements contained in the Query. Requires you to have access to the
workgroup in which the query ran. Running queries against an external catalog requires
GetDataCatalog permission to the catalog. For code samples using the Amazon Web Services
SDK for Java, see Examples and Code Samples in the Amazon Athena User Guide.
# Arguments
- `query_string`: The SQL query statements to be executed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the query is idempotent (executes only once). If another StartQueryExecution request
is received, the same response is returned and another query is not created. An error is
returned if a parameter, such as QueryString, has changed. A call to StartQueryExecution
that uses a previous client request token returns the same QueryExecutionId even if the
requester doesn't have permission on the tables specified in QueryString. This token is
listed as not required because Amazon Web Services SDKs (for example the Amazon Web
Services SDK for Java) auto-generate the token for users. If you are not using the Amazon
Web Services SDK or the Amazon Web Services CLI, you must provide this token or the action
will fail.
- `"ExecutionParameters"`: A list of values for the parameters in a query. The values are
applied sequentially to the parameters in the query in the order in which the parameters
occur.
- `"QueryExecutionContext"`: The database within which the query executes.
- `"ResultConfiguration"`: Specifies information about where and how to save the results of
the query execution. If the query runs in a workgroup, then workgroup's settings may
override query settings. This affects the query results location. The workgroup settings
override is specified in EnforceWorkGroupConfiguration (true/false) in the
WorkGroupConfiguration. See WorkGroupConfigurationEnforceWorkGroupConfiguration.
- `"ResultReuseConfiguration"`: Specifies the query result reuse behavior for the query.
- `"WorkGroup"`: The name of the workgroup in which the query is being started.
"""
function start_query_execution(
QueryString; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"StartQueryExecution",
Dict{String,Any}(
"QueryString" => QueryString, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_query_execution(
QueryString,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"StartQueryExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"QueryString" => QueryString, "ClientRequestToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_session(engine_configuration, work_group)
start_session(engine_configuration, work_group, params::Dict{String,<:Any})
Creates a session for running calculations within a workgroup. The session is ready when it
reaches an IDLE state.
# Arguments
- `engine_configuration`: Contains engine data processing unit (DPU) configuration settings
and parameter mappings.
- `work_group`: The workgroup to which the session belongs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the session is idempotent (executes only once). If another StartSessionRequest is
received, the same response is returned and another session is not created. If a parameter
has changed, an error is returned. This token is listed as not required because Amazon Web
Services SDKs (for example the Amazon Web Services SDK for Java) auto-generate the token
for users. If you are not using the Amazon Web Services SDK or the Amazon Web Services CLI,
you must provide this token or the action will fail.
- `"Description"`: The session description.
- `"NotebookVersion"`: The notebook version. This value is supplied automatically for
notebook sessions in the Athena console and is not required for programmatic session
access. The only valid notebook version is Athena notebook version 1. If you specify a
value for NotebookVersion, you must also specify a value for NotebookId. See
EngineConfigurationAdditionalConfigs.
- `"SessionIdleTimeoutInMinutes"`: The idle timeout in minutes for the session.
"""
function start_session(
EngineConfiguration, WorkGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"StartSession",
Dict{String,Any}(
"EngineConfiguration" => EngineConfiguration, "WorkGroup" => WorkGroup
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_session(
EngineConfiguration,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"StartSession",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EngineConfiguration" => EngineConfiguration, "WorkGroup" => WorkGroup
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_calculation_execution(calculation_execution_id)
stop_calculation_execution(calculation_execution_id, params::Dict{String,<:Any})
Requests the cancellation of a calculation. A StopCalculationExecution call on a
calculation that is already in a terminal state (for example, STOPPED, FAILED, or
COMPLETED) succeeds but has no effect. Cancelling a calculation is done on a best effort
basis. If a calculation cannot be cancelled, you can be charged for its completion. If you
are concerned about being charged for a calculation that cannot be cancelled, consider
terminating the session in which the calculation is running.
# Arguments
- `calculation_execution_id`: The calculation execution UUID.
"""
function stop_calculation_execution(
CalculationExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"StopCalculationExecution",
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_calculation_execution(
CalculationExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"StopCalculationExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("CalculationExecutionId" => CalculationExecutionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_query_execution(query_execution_id)
stop_query_execution(query_execution_id, params::Dict{String,<:Any})
Stops a query execution. Requires you to have access to the workgroup in which the query
ran.
# Arguments
- `query_execution_id`: The unique ID of the query execution to stop.
"""
function stop_query_execution(
QueryExecutionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"StopQueryExecution",
Dict{String,Any}("QueryExecutionId" => QueryExecutionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_query_execution(
QueryExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"StopQueryExecution",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("QueryExecutionId" => QueryExecutionId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds one or more tags to an Athena resource. A tag is a label that you assign to a
resource. Each tag consists of a key and an optional value, both of which you define. For
example, you can use tags to categorize Athena workgroups, data catalogs, or capacity
reservations by purpose, owner, or environment. Use a consistent set of tag keys to make it
easier to search and filter the resources in your account. For best practices, see Tagging
Best Practices. Tag keys can be from 1 to 128 UTF-8 Unicode characters, and tag values can
be from 0 to 256 UTF-8 Unicode characters. Tags can use letters and numbers representable
in UTF-8, and the following characters: + - = . _ : / @. Tag keys and values are
case-sensitive. Tag keys must be unique per resource. If you specify more than one tag,
separate them by commas.
# Arguments
- `resource_arn`: Specifies the ARN of the Athena resource to which tags are to be added.
- `tags`: A collection of one or more tags, separated by commas, to be added to an Athena
resource.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
terminate_session(session_id)
terminate_session(session_id, params::Dict{String,<:Any})
Terminates an active session. A TerminateSession call on a session that is already inactive
(for example, in a FAILED, TERMINATED or TERMINATING state) succeeds but has no effect.
Calculations running in the session when TerminateSession is called are forcefully stopped,
but may display as FAILED instead of STOPPED.
# Arguments
- `session_id`: The session ID.
"""
function terminate_session(SessionId; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"TerminateSession",
Dict{String,Any}("SessionId" => SessionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function terminate_session(
SessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"TerminateSession",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SessionId" => SessionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes one or more tags from an Athena resource.
# Arguments
- `resource_arn`: Specifies the ARN of the resource from which tags are to be removed.
- `tag_keys`: A comma-separated list of one or more tag keys whose tags are to be removed
from the specified resource.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_capacity_reservation(name, target_dpus)
update_capacity_reservation(name, target_dpus, params::Dict{String,<:Any})
Updates the number of requested data processing units for the capacity reservation with the
specified name.
# Arguments
- `name`: The name of the capacity reservation.
- `target_dpus`: The new number of requested data processing units.
"""
function update_capacity_reservation(
Name, TargetDpus; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"UpdateCapacityReservation",
Dict{String,Any}("Name" => Name, "TargetDpus" => TargetDpus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_capacity_reservation(
Name,
TargetDpus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateCapacityReservation",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "TargetDpus" => TargetDpus), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_data_catalog(name, type)
update_data_catalog(name, type, params::Dict{String,<:Any})
Updates the data catalog that has the specified name.
# Arguments
- `name`: The name of the data catalog to update. The catalog name must be unique for the
Amazon Web Services account and can use a maximum of 127 alphanumeric, underscore, at sign,
or hyphen characters. The remainder of the length constraint of 256 is reserved for use by
Athena.
- `type`: Specifies the type of data catalog to update. Specify LAMBDA for a federated
catalog, HIVE for an external hive metastore, or GLUE for an Glue Data Catalog.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: New or modified text that describes the data catalog.
- `"Parameters"`: Specifies the Lambda function or functions to use for updating the data
catalog. This is a mapping whose values depend on the catalog type. For the HIVE data
catalog type, use the following syntax. The metadata-function parameter is required. The
sdk-version parameter is optional and defaults to the currently supported version.
metadata-function=lambda_arn, sdk-version=version_number For the LAMBDA data catalog
type, use one of the following sets of required parameters, but not both. If you have one
Lambda function that processes metadata and another for reading the actual data, use the
following syntax. Both parameters are required. metadata-function=lambda_arn,
record-function=lambda_arn If you have a composite Lambda function that processes both
metadata and data, use the following syntax to specify your Lambda function.
function=lambda_arn
"""
function update_data_catalog(Name, Type; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"UpdateDataCatalog",
Dict{String,Any}("Name" => Name, "Type" => Type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_data_catalog(
Name,
Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateDataCatalog",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Name" => Name, "Type" => Type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_named_query(name, named_query_id, query_string)
update_named_query(name, named_query_id, query_string, params::Dict{String,<:Any})
Updates a NamedQuery object. The database or workgroup cannot be updated.
# Arguments
- `name`: The name of the query.
- `named_query_id`: The unique identifier (UUID) of the query.
- `query_string`: The contents of the query with all query statements.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The query description.
"""
function update_named_query(
Name, NamedQueryId, QueryString; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"UpdateNamedQuery",
Dict{String,Any}(
"Name" => Name, "NamedQueryId" => NamedQueryId, "QueryString" => QueryString
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_named_query(
Name,
NamedQueryId,
QueryString,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateNamedQuery",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"NamedQueryId" => NamedQueryId,
"QueryString" => QueryString,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_notebook(notebook_id, payload, type)
update_notebook(notebook_id, payload, type, params::Dict{String,<:Any})
Updates the contents of a Spark notebook.
# Arguments
- `notebook_id`: The ID of the notebook to update.
- `payload`: The updated content for the notebook.
- `type`: The notebook content type. Currently, the only valid type is IPYNB.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the notebook is idempotent (executes only once). This token is listed as not
required because Amazon Web Services SDKs (for example the Amazon Web Services SDK for
Java) auto-generate the token for you. If you are not using the Amazon Web Services SDK or
the Amazon Web Services CLI, you must provide this token or the action will fail.
- `"SessionId"`: The active notebook session ID. Required if the notebook has an active
session.
"""
function update_notebook(
NotebookId, Payload, Type; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"UpdateNotebook",
Dict{String,Any}("NotebookId" => NotebookId, "Payload" => Payload, "Type" => Type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_notebook(
NotebookId,
Payload,
Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateNotebook",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"NotebookId" => NotebookId, "Payload" => Payload, "Type" => Type
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_notebook_metadata(name, notebook_id)
update_notebook_metadata(name, notebook_id, params::Dict{String,<:Any})
Updates the metadata for a notebook.
# Arguments
- `name`: The name to update the notebook to.
- `notebook_id`: The ID of the notebook to update the metadata for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique case-sensitive string used to ensure the request to
create the notebook is idempotent (executes only once). This token is listed as not
required because Amazon Web Services SDKs (for example the Amazon Web Services SDK for
Java) auto-generate the token for you. If you are not using the Amazon Web Services SDK or
the Amazon Web Services CLI, you must provide this token or the action will fail.
"""
function update_notebook_metadata(
Name, NotebookId; aws_config::AbstractAWSConfig=global_aws_config()
)
return athena(
"UpdateNotebookMetadata",
Dict{String,Any}("Name" => Name, "NotebookId" => NotebookId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_notebook_metadata(
Name,
NotebookId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateNotebookMetadata",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "NotebookId" => NotebookId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_prepared_statement(query_statement, statement_name, work_group)
update_prepared_statement(query_statement, statement_name, work_group, params::Dict{String,<:Any})
Updates a prepared statement.
# Arguments
- `query_statement`: The query string for the prepared statement.
- `statement_name`: The name of the prepared statement.
- `work_group`: The workgroup for the prepared statement.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the prepared statement.
"""
function update_prepared_statement(
QueryStatement,
StatementName,
WorkGroup;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdatePreparedStatement",
Dict{String,Any}(
"QueryStatement" => QueryStatement,
"StatementName" => StatementName,
"WorkGroup" => WorkGroup,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_prepared_statement(
QueryStatement,
StatementName,
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdatePreparedStatement",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"QueryStatement" => QueryStatement,
"StatementName" => StatementName,
"WorkGroup" => WorkGroup,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_work_group(work_group)
update_work_group(work_group, params::Dict{String,<:Any})
Updates the workgroup with the specified name. The workgroup's name cannot be changed. Only
ConfigurationUpdates can be specified.
# Arguments
- `work_group`: The specified workgroup that will be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConfigurationUpdates"`: Contains configuration updates for an Athena SQL workgroup.
- `"Description"`: The workgroup description.
- `"State"`: The workgroup state that will be updated for the given workgroup.
"""
function update_work_group(WorkGroup; aws_config::AbstractAWSConfig=global_aws_config())
return athena(
"UpdateWorkGroup",
Dict{String,Any}("WorkGroup" => WorkGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_work_group(
WorkGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return athena(
"UpdateWorkGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("WorkGroup" => WorkGroup), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 86955 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: auditmanager
using AWS.Compat
using AWS.UUIDs
"""
associate_assessment_report_evidence_folder(assessment_id, evidence_folder_id)
associate_assessment_report_evidence_folder(assessment_id, evidence_folder_id, params::Dict{String,<:Any})
Associates an evidence folder to an assessment report in an Audit Manager assessment.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `evidence_folder_id`: The identifier for the folder that the evidence is stored in.
"""
function associate_assessment_report_evidence_folder(
assessmentId, evidenceFolderId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/associateToAssessmentReport",
Dict{String,Any}("evidenceFolderId" => evidenceFolderId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_assessment_report_evidence_folder(
assessmentId,
evidenceFolderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/associateToAssessmentReport",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("evidenceFolderId" => evidenceFolderId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_associate_assessment_report_evidence(assessment_id, evidence_folder_id, evidence_ids)
batch_associate_assessment_report_evidence(assessment_id, evidence_folder_id, evidence_ids, params::Dict{String,<:Any})
Associates a list of evidence to an assessment report in an Audit Manager assessment.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `evidence_folder_id`: The identifier for the folder that the evidence is stored in.
- `evidence_ids`: The list of evidence identifiers.
"""
function batch_associate_assessment_report_evidence(
assessmentId,
evidenceFolderId,
evidenceIds;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/batchAssociateToAssessmentReport",
Dict{String,Any}(
"evidenceFolderId" => evidenceFolderId, "evidenceIds" => evidenceIds
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_associate_assessment_report_evidence(
assessmentId,
evidenceFolderId,
evidenceIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/batchAssociateToAssessmentReport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"evidenceFolderId" => evidenceFolderId, "evidenceIds" => evidenceIds
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_create_delegation_by_assessment(assessment_id, create_delegation_requests)
batch_create_delegation_by_assessment(assessment_id, create_delegation_requests, params::Dict{String,<:Any})
Creates a batch of delegations for an assessment in Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `create_delegation_requests`: The API request to batch create delegations in Audit
Manager.
"""
function batch_create_delegation_by_assessment(
assessmentId,
createDelegationRequests;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/delegations",
Dict{String,Any}("createDelegationRequests" => createDelegationRequests);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_delegation_by_assessment(
assessmentId,
createDelegationRequests,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/delegations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("createDelegationRequests" => createDelegationRequests),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_delegation_by_assessment(assessment_id, delegation_ids)
batch_delete_delegation_by_assessment(assessment_id, delegation_ids, params::Dict{String,<:Any})
Deletes a batch of delegations for an assessment in Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `delegation_ids`: The identifiers for the delegations.
"""
function batch_delete_delegation_by_assessment(
assessmentId, delegationIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/delegations",
Dict{String,Any}("delegationIds" => delegationIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_delegation_by_assessment(
assessmentId,
delegationIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/delegations",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("delegationIds" => delegationIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_disassociate_assessment_report_evidence(assessment_id, evidence_folder_id, evidence_ids)
batch_disassociate_assessment_report_evidence(assessment_id, evidence_folder_id, evidence_ids, params::Dict{String,<:Any})
Disassociates a list of evidence from an assessment report in Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `evidence_folder_id`: The identifier for the folder that the evidence is stored in.
- `evidence_ids`: The list of evidence identifiers.
"""
function batch_disassociate_assessment_report_evidence(
assessmentId,
evidenceFolderId,
evidenceIds;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/batchDisassociateFromAssessmentReport",
Dict{String,Any}(
"evidenceFolderId" => evidenceFolderId, "evidenceIds" => evidenceIds
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_disassociate_assessment_report_evidence(
assessmentId,
evidenceFolderId,
evidenceIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/batchDisassociateFromAssessmentReport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"evidenceFolderId" => evidenceFolderId, "evidenceIds" => evidenceIds
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_import_evidence_to_assessment_control(assessment_id, control_id, control_set_id, manual_evidence)
batch_import_evidence_to_assessment_control(assessment_id, control_id, control_set_id, manual_evidence, params::Dict{String,<:Any})
Adds one or more pieces of evidence to a control in an Audit Manager assessment. You can
import manual evidence from any S3 bucket by specifying the S3 URI of the object. You can
also upload a file from your browser, or enter plain text in response to a risk assessment
question. The following restrictions apply to this action: manualEvidence can be only
one of the following: evidenceFileName, s3ResourcePath, or textResponse Maximum size of
an individual evidence file: 100 MB Number of daily manual evidence uploads per control:
100 Supported file formats: See Supported file types for manual evidence in the Audit
Manager User Guide For more information about Audit Manager service restrictions, see
Quotas and restrictions for Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `control_id`: The identifier for the control.
- `control_set_id`: The identifier for the control set.
- `manual_evidence`: The list of manual evidence objects.
"""
function batch_import_evidence_to_assessment_control(
assessmentId,
controlId,
controlSetId,
manualEvidence;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/controls/$(controlId)/evidence",
Dict{String,Any}("manualEvidence" => manualEvidence);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_import_evidence_to_assessment_control(
assessmentId,
controlId,
controlSetId,
manualEvidence,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/controls/$(controlId)/evidence",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("manualEvidence" => manualEvidence), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_assessment(assessment_reports_destination, framework_id, name, roles, scope)
create_assessment(assessment_reports_destination, framework_id, name, roles, scope, params::Dict{String,<:Any})
Creates an assessment in Audit Manager.
# Arguments
- `assessment_reports_destination`: The assessment report storage destination for the
assessment that's being created.
- `framework_id`: The identifier for the framework that the assessment will be created
from.
- `name`: The name of the assessment to be created.
- `roles`: The list of roles for the assessment.
- `scope`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The optional description of the assessment to be created.
- `"tags"`: The tags that are associated with the assessment.
"""
function create_assessment(
assessmentReportsDestination,
frameworkId,
name,
roles,
scope;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments",
Dict{String,Any}(
"assessmentReportsDestination" => assessmentReportsDestination,
"frameworkId" => frameworkId,
"name" => name,
"roles" => roles,
"scope" => scope,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_assessment(
assessmentReportsDestination,
frameworkId,
name,
roles,
scope,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"assessmentReportsDestination" => assessmentReportsDestination,
"frameworkId" => frameworkId,
"name" => name,
"roles" => roles,
"scope" => scope,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_assessment_framework(control_sets, name)
create_assessment_framework(control_sets, name, params::Dict{String,<:Any})
Creates a custom framework in Audit Manager.
# Arguments
- `control_sets`: The control sets that are associated with the framework.
- `name`: The name of the new custom framework.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"complianceType"`: The compliance type that the new custom framework supports, such as
CIS or HIPAA.
- `"description"`: An optional description for the new custom framework.
- `"tags"`: The tags that are associated with the framework.
"""
function create_assessment_framework(
controlSets, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/assessmentFrameworks",
Dict{String,Any}("controlSets" => controlSets, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_assessment_framework(
controlSets,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessmentFrameworks",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("controlSets" => controlSets, "name" => name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_assessment_report(assessment_id, name)
create_assessment_report(assessment_id, name, params::Dict{String,<:Any})
Creates an assessment report for the specified assessment.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `name`: The name of the new assessment report.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the assessment report.
- `"queryStatement"`: A SQL statement that represents an evidence finder query. Provide
this parameter when you want to generate an assessment report from the results of an
evidence finder search query. When you use this parameter, Audit Manager generates a
one-time report using only the evidence from the query output. This report does not include
any assessment evidence that was manually added to a report using the console, or
associated with a report using the API. To use this parameter, the enablementStatus of
evidence finder must be ENABLED. For examples and help resolving queryStatement
validation exceptions, see Troubleshooting evidence finder issues in the Audit Manager User
Guide.
"""
function create_assessment_report(
assessmentId, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/reports",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_assessment_report(
assessmentId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessments/$(assessmentId)/reports",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_control(control_mapping_sources, name)
create_control(control_mapping_sources, name, params::Dict{String,<:Any})
Creates a new custom control in Audit Manager.
# Arguments
- `control_mapping_sources`: The data mapping sources for the control.
- `name`: The name of the control.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actionPlanInstructions"`: The recommended actions to carry out if the control isn't
fulfilled.
- `"actionPlanTitle"`: The title of the action plan for remediating the control.
- `"description"`: The description of the control.
- `"tags"`: The tags that are associated with the control.
- `"testingInformation"`: The steps to follow to determine if the control is satisfied.
"""
function create_control(
controlMappingSources, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/controls",
Dict{String,Any}("controlMappingSources" => controlMappingSources, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_control(
controlMappingSources,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/controls",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"controlMappingSources" => controlMappingSources, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_assessment(assessment_id)
delete_assessment(assessment_id, params::Dict{String,<:Any})
Deletes an assessment in Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
"""
function delete_assessment(assessmentId; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"DELETE",
"/assessments/$(assessmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_assessment(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/assessments/$(assessmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_assessment_framework(framework_id)
delete_assessment_framework(framework_id, params::Dict{String,<:Any})
Deletes a custom framework in Audit Manager.
# Arguments
- `framework_id`: The identifier for the custom framework.
"""
function delete_assessment_framework(
frameworkId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"DELETE",
"/assessmentFrameworks/$(frameworkId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_assessment_framework(
frameworkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/assessmentFrameworks/$(frameworkId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_assessment_framework_share(request_id, request_type)
delete_assessment_framework_share(request_id, request_type, params::Dict{String,<:Any})
Deletes a share request for a custom framework in Audit Manager.
# Arguments
- `request_id`: The unique identifier for the share request to be deleted.
- `request_type`: Specifies whether the share request is a sent request or a received
request.
"""
function delete_assessment_framework_share(
requestId, requestType; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"DELETE",
"/assessmentFrameworkShareRequests/$(requestId)",
Dict{String,Any}("requestType" => requestType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_assessment_framework_share(
requestId,
requestType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/assessmentFrameworkShareRequests/$(requestId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("requestType" => requestType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_assessment_report(assessment_id, assessment_report_id)
delete_assessment_report(assessment_id, assessment_report_id, params::Dict{String,<:Any})
Deletes an assessment report in Audit Manager. When you run the DeleteAssessmentReport
operation, Audit Manager attempts to delete the following data: The specified assessment
report that’s stored in your S3 bucket The associated metadata that’s stored in Audit
Manager If Audit Manager can’t access the assessment report in your S3 bucket, the
report isn’t deleted. In this event, the DeleteAssessmentReport operation doesn’t fail.
Instead, it proceeds to delete the associated metadata only. You must then delete the
assessment report from the S3 bucket yourself. This scenario happens when Audit Manager
receives a 403 (Forbidden) or 404 (Not Found) error from Amazon S3. To avoid this, make
sure that your S3 bucket is available, and that you configured the correct permissions for
Audit Manager to delete resources in your S3 bucket. For an example permissions policy that
you can use, see Assessment report destination permissions in the Audit Manager User Guide.
For information about the issues that could cause a 403 (Forbidden) or 404 (Not Found)
error from Amazon S3, see List of Error Codes in the Amazon Simple Storage Service API
Reference.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `assessment_report_id`: The unique identifier for the assessment report.
"""
function delete_assessment_report(
assessmentId, assessmentReportId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"DELETE",
"/assessments/$(assessmentId)/reports/$(assessmentReportId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_assessment_report(
assessmentId,
assessmentReportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/assessments/$(assessmentId)/reports/$(assessmentReportId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_control(control_id)
delete_control(control_id, params::Dict{String,<:Any})
Deletes a custom control in Audit Manager. When you invoke this operation, the custom
control is deleted from any frameworks or assessments that it’s currently part of. As a
result, Audit Manager will stop collecting evidence for that custom control in all of your
assessments. This includes assessments that you previously created before you deleted the
custom control.
# Arguments
- `control_id`: The unique identifier for the control.
"""
function delete_control(controlId; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"DELETE",
"/controls/$(controlId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_control(
controlId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/controls/$(controlId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_account()
deregister_account(params::Dict{String,<:Any})
Deregisters an account in Audit Manager. Before you deregister, you can use the
UpdateSettings API operation to set your preferred data retention policy. By default, Audit
Manager retains your data. If you want to delete your data, you can use the
DeregistrationPolicy attribute to request the deletion of your data. For more information
about data retention, see Data Protection in the Audit Manager User Guide.
"""
function deregister_account(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"POST",
"/account/deregisterAccount";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/account/deregisterAccount",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_organization_admin_account()
deregister_organization_admin_account(params::Dict{String,<:Any})
Removes the specified Amazon Web Services account as a delegated administrator for Audit
Manager. When you remove a delegated administrator from your Audit Manager settings, you
continue to have access to the evidence that you previously collected under that account.
This is also the case when you deregister a delegated administrator from Organizations.
However, Audit Manager stops collecting and attaching evidence to that delegated
administrator account moving forward. Keep in mind the following cleanup task if you use
evidence finder: Before you use your management account to remove a delegated
administrator, make sure that the current delegated administrator account signs in to Audit
Manager and disables evidence finder first. Disabling evidence finder automatically deletes
the event data store that was created in their account when they enabled evidence finder.
If this task isn’t completed, the event data store remains in their account. In this
case, we recommend that the original delegated administrator goes to CloudTrail Lake and
manually deletes the event data store. This cleanup task is necessary to ensure that you
don't end up with multiple event data stores. Audit Manager ignores an unused event data
store after you remove or change a delegated administrator account. However, the unused
event data store continues to incur storage costs from CloudTrail Lake if you don't delete
it. When you deregister a delegated administrator account for Audit Manager, the data for
that account isn’t deleted. If you want to delete resource data for a delegated
administrator account, you must perform that task separately before you deregister the
account. Either, you can do this in the Audit Manager console. Or, you can use one of the
delete API operations that are provided by Audit Manager. To delete your Audit Manager
resource data, see the following instructions: DeleteAssessment (see also: Deleting an
assessment in the Audit Manager User Guide) DeleteAssessmentFramework (see also:
Deleting a custom framework in the Audit Manager User Guide)
DeleteAssessmentFrameworkShare (see also: Deleting a share request in the Audit Manager
User Guide) DeleteAssessmentReport (see also: Deleting an assessment report in the Audit
Manager User Guide) DeleteControl (see also: Deleting a custom control in the Audit
Manager User Guide) At this time, Audit Manager doesn't provide an option to delete
evidence for a specific delegated administrator. Instead, when your management account
deregisters Audit Manager, we perform a cleanup for the current delegated administrator
account at the time of deregistration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"adminAccountId"`: The identifier for the administrator account.
"""
function deregister_organization_admin_account(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/account/deregisterOrganizationAdminAccount";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_organization_admin_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/account/deregisterOrganizationAdminAccount",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_assessment_report_evidence_folder(assessment_id, evidence_folder_id)
disassociate_assessment_report_evidence_folder(assessment_id, evidence_folder_id, params::Dict{String,<:Any})
Disassociates an evidence folder from the specified assessment report in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `evidence_folder_id`: The unique identifier for the folder that the evidence is stored
in.
"""
function disassociate_assessment_report_evidence_folder(
assessmentId, evidenceFolderId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/disassociateFromAssessmentReport",
Dict{String,Any}("evidenceFolderId" => evidenceFolderId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_assessment_report_evidence_folder(
assessmentId,
evidenceFolderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/disassociateFromAssessmentReport",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("evidenceFolderId" => evidenceFolderId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account_status()
get_account_status(params::Dict{String,<:Any})
Gets the registration status of an account in Audit Manager.
"""
function get_account_status(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/account/status"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_account_status(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/account/status",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_assessment(assessment_id)
get_assessment(assessment_id, params::Dict{String,<:Any})
Gets information about a specified assessment.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
"""
function get_assessment(assessmentId; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/assessments/$(assessmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_assessment(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_assessment_framework(framework_id)
get_assessment_framework(framework_id, params::Dict{String,<:Any})
Gets information about a specified framework.
# Arguments
- `framework_id`: The identifier for the framework.
"""
function get_assessment_framework(
frameworkId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessmentFrameworks/$(frameworkId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_assessment_framework(
frameworkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessmentFrameworks/$(frameworkId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_assessment_report_url(assessment_id, assessment_report_id)
get_assessment_report_url(assessment_id, assessment_report_id, params::Dict{String,<:Any})
Gets the URL of an assessment report in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `assessment_report_id`: The unique identifier for the assessment report.
"""
function get_assessment_report_url(
assessmentId, assessmentReportId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/reports/$(assessmentReportId)/url";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_assessment_report_url(
assessmentId,
assessmentReportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/reports/$(assessmentReportId)/url",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_change_logs(assessment_id)
get_change_logs(assessment_id, params::Dict{String,<:Any})
Gets a list of changelogs from Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"controlId"`: The unique identifier for the control.
- `"controlSetId"`: The unique identifier for the control set.
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function get_change_logs(assessmentId; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/assessments/$(assessmentId)/changelogs";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_change_logs(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/changelogs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_control(control_id)
get_control(control_id, params::Dict{String,<:Any})
Gets information about a specified control.
# Arguments
- `control_id`: The identifier for the control.
"""
function get_control(controlId; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/controls/$(controlId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_control(
controlId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/controls/$(controlId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_delegations()
get_delegations(params::Dict{String,<:Any})
Gets a list of delegations from an audit owner to a delegate.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function get_delegations(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/delegations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_delegations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/delegations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence(assessment_id, control_set_id, evidence_folder_id, evidence_id)
get_evidence(assessment_id, control_set_id, evidence_folder_id, evidence_id, params::Dict{String,<:Any})
Gets information about a specified evidence item.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `control_set_id`: The unique identifier for the control set.
- `evidence_folder_id`: The unique identifier for the folder that the evidence is stored
in.
- `evidence_id`: The unique identifier for the evidence.
"""
function get_evidence(
assessmentId,
controlSetId,
evidenceFolderId,
evidenceId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)/evidence/$(evidenceId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence(
assessmentId,
controlSetId,
evidenceFolderId,
evidenceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)/evidence/$(evidenceId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence_by_evidence_folder(assessment_id, control_set_id, evidence_folder_id)
get_evidence_by_evidence_folder(assessment_id, control_set_id, evidence_folder_id, params::Dict{String,<:Any})
Gets all evidence from a specified evidence folder in Audit Manager.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `control_set_id`: The identifier for the control set.
- `evidence_folder_id`: The unique identifier for the folder that the evidence is stored
in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function get_evidence_by_evidence_folder(
assessmentId,
controlSetId,
evidenceFolderId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)/evidence";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence_by_evidence_folder(
assessmentId,
controlSetId,
evidenceFolderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)/evidence",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence_file_upload_url(file_name)
get_evidence_file_upload_url(file_name, params::Dict{String,<:Any})
Creates a presigned Amazon S3 URL that can be used to upload a file as manual evidence. For
instructions on how to use this operation, see Upload a file from your browser in the
Audit Manager User Guide. The following restrictions apply to this operation: Maximum
size of an individual evidence file: 100 MB Number of daily manual evidence uploads per
control: 100 Supported file formats: See Supported file types for manual evidence in the
Audit Manager User Guide For more information about Audit Manager service restrictions,
see Quotas and restrictions for Audit Manager.
# Arguments
- `file_name`: The file that you want to upload. For a list of supported file formats, see
Supported file types for manual evidence in the Audit Manager User Guide.
"""
function get_evidence_file_upload_url(
fileName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/evidenceFileUploadUrl",
Dict{String,Any}("fileName" => fileName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence_file_upload_url(
fileName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/evidenceFileUploadUrl",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("fileName" => fileName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence_folder(assessment_id, control_set_id, evidence_folder_id)
get_evidence_folder(assessment_id, control_set_id, evidence_folder_id, params::Dict{String,<:Any})
Gets an evidence folder from a specified assessment in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `control_set_id`: The unique identifier for the control set.
- `evidence_folder_id`: The unique identifier for the folder that the evidence is stored
in.
"""
function get_evidence_folder(
assessmentId,
controlSetId,
evidenceFolderId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence_folder(
assessmentId,
controlSetId,
evidenceFolderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/evidenceFolders/$(evidenceFolderId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence_folders_by_assessment(assessment_id)
get_evidence_folders_by_assessment(assessment_id, params::Dict{String,<:Any})
Gets the evidence folders from a specified assessment in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function get_evidence_folders_by_assessment(
assessmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/evidenceFolders";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence_folders_by_assessment(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/evidenceFolders",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evidence_folders_by_assessment_control(assessment_id, control_id, control_set_id)
get_evidence_folders_by_assessment_control(assessment_id, control_id, control_set_id, params::Dict{String,<:Any})
Gets a list of evidence folders that are associated with a specified control in an Audit
Manager assessment.
# Arguments
- `assessment_id`: The identifier for the assessment.
- `control_id`: The identifier for the control.
- `control_set_id`: The identifier for the control set.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function get_evidence_folders_by_assessment_control(
assessmentId, controlId, controlSetId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/evidenceFolders-by-assessment-control/$(controlSetId)/$(controlId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evidence_folders_by_assessment_control(
assessmentId,
controlId,
controlSetId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessments/$(assessmentId)/evidenceFolders-by-assessment-control/$(controlSetId)/$(controlId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_insights()
get_insights(params::Dict{String,<:Any})
Gets the latest analytics data for all your current active assessments.
"""
function get_insights(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/insights"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_insights(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET", "/insights", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_insights_by_assessment(assessment_id)
get_insights_by_assessment(assessment_id, params::Dict{String,<:Any})
Gets the latest analytics data for a specific active assessment.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
"""
function get_insights_by_assessment(
assessmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/insights/assessments/$(assessmentId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_insights_by_assessment(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/insights/assessments/$(assessmentId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_organization_admin_account()
get_organization_admin_account(params::Dict{String,<:Any})
Gets the name of the delegated Amazon Web Services administrator account for a specified
organization.
"""
function get_organization_admin_account(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/account/organizationAdminAccount";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_organization_admin_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/account/organizationAdminAccount",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_services_in_scope()
get_services_in_scope(params::Dict{String,<:Any})
Gets a list of the Amazon Web Services from which Audit Manager can collect evidence.
Audit Manager defines which Amazon Web Services are in scope for an assessment. Audit
Manager infers this scope by examining the assessment’s controls and their data sources,
and then mapping this information to one or more of the corresponding Amazon Web Services
that are in this list. For information about why it's no longer possible to specify
services in scope manually, see I can't edit the services in scope for my assessment in the
Troubleshooting section of the Audit Manager user guide.
"""
function get_services_in_scope(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/services"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_services_in_scope(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET", "/services", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_settings(attribute)
get_settings(attribute, params::Dict{String,<:Any})
Gets the settings for a specified Amazon Web Services account.
# Arguments
- `attribute`: The list of setting attribute enum values.
"""
function get_settings(attribute; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/settings/$(attribute)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_settings(
attribute,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/settings/$(attribute)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_assessment_control_insights_by_control_domain(assessment_id, control_domain_id)
list_assessment_control_insights_by_control_domain(assessment_id, control_domain_id, params::Dict{String,<:Any})
Lists the latest analytics data for controls within a specific control domain and a
specific active assessment. Control insights are listed only if the control belongs to the
control domain and assessment that was specified. Moreover, the control must have collected
evidence on the lastUpdated date of controlInsightsByAssessment. If neither of these
conditions are met, no data is listed for that control.
# Arguments
- `assessment_id`: The unique identifier for the active assessment.
- `control_domain_id`: The unique identifier for the control domain. Audit Manager
supports the control domains that are provided by Amazon Web Services Control Catalog. For
information about how to find a list of available control domains, see ListDomains in the
Amazon Web Services Control Catalog API Reference.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_assessment_control_insights_by_control_domain(
assessmentId, controlDomainId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/insights/controls-by-assessment",
Dict{String,Any}(
"assessmentId" => assessmentId, "controlDomainId" => controlDomainId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_assessment_control_insights_by_control_domain(
assessmentId,
controlDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/insights/controls-by-assessment",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"assessmentId" => assessmentId, "controlDomainId" => controlDomainId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_assessment_framework_share_requests(request_type)
list_assessment_framework_share_requests(request_type, params::Dict{String,<:Any})
Returns a list of sent or received share requests for custom frameworks in Audit Manager.
# Arguments
- `request_type`: Specifies whether the share request is a sent request or a received
request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_assessment_framework_share_requests(
requestType; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessmentFrameworkShareRequests",
Dict{String,Any}("requestType" => requestType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_assessment_framework_share_requests(
requestType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessmentFrameworkShareRequests",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("requestType" => requestType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_assessment_frameworks(framework_type)
list_assessment_frameworks(framework_type, params::Dict{String,<:Any})
Returns a list of the frameworks that are available in the Audit Manager framework
library.
# Arguments
- `framework_type`: The type of framework, such as a standard framework or a custom
framework.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_assessment_frameworks(
frameworkType; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessmentFrameworks",
Dict{String,Any}("frameworkType" => frameworkType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_assessment_frameworks(
frameworkType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/assessmentFrameworks",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("frameworkType" => frameworkType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_assessment_reports()
list_assessment_reports(params::Dict{String,<:Any})
Returns a list of assessment reports created in Audit Manager.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_assessment_reports(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/assessmentReports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_assessment_reports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessmentReports",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_assessments()
list_assessments(params::Dict{String,<:Any})
Returns a list of current and past assessments from Audit Manager.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
- `"status"`: The current status of the assessment.
"""
function list_assessments(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/assessments"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_assessments(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/assessments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_control_domain_insights()
list_control_domain_insights(params::Dict{String,<:Any})
Lists the latest analytics data for control domains across all of your active assessments.
Audit Manager supports the control domains that are provided by Amazon Web Services Control
Catalog. For information about how to find a list of available control domains, see
ListDomains in the Amazon Web Services Control Catalog API Reference. A control domain is
listed only if at least one of the controls within that domain collected evidence on the
lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed
for that control domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_control_domain_insights(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/insights/control-domains";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_control_domain_insights(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/insights/control-domains",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_control_domain_insights_by_assessment(assessment_id)
list_control_domain_insights_by_assessment(assessment_id, params::Dict{String,<:Any})
Lists analytics data for control domains within a specified active assessment. Audit
Manager supports the control domains that are provided by Amazon Web Services Control
Catalog. For information about how to find a list of available control domains, see
ListDomains in the Amazon Web Services Control Catalog API Reference. A control domain is
listed only if at least one of the controls within that domain collected evidence on the
lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed
for that domain.
# Arguments
- `assessment_id`: The unique identifier for the active assessment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_control_domain_insights_by_assessment(
assessmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/insights/control-domains-by-assessment",
Dict{String,Any}("assessmentId" => assessmentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_control_domain_insights_by_assessment(
assessmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/insights/control-domains-by-assessment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("assessmentId" => assessmentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_control_insights_by_control_domain(control_domain_id)
list_control_insights_by_control_domain(control_domain_id, params::Dict{String,<:Any})
Lists the latest analytics data for controls within a specific control domain across all
active assessments. Control insights are listed only if the control belongs to the control
domain that was specified and the control collected evidence on the lastUpdated date of
controlInsightsMetadata. If neither of these conditions are met, no data is listed for that
control.
# Arguments
- `control_domain_id`: The unique identifier for the control domain. Audit Manager
supports the control domains that are provided by Amazon Web Services Control Catalog. For
information about how to find a list of available control domains, see ListDomains in the
Amazon Web Services Control Catalog API Reference.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_control_insights_by_control_domain(
controlDomainId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/insights/controls",
Dict{String,Any}("controlDomainId" => controlDomainId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_control_insights_by_control_domain(
controlDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/insights/controls",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("controlDomainId" => controlDomainId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_controls(control_type)
list_controls(control_type, params::Dict{String,<:Any})
Returns a list of controls from Audit Manager.
# Arguments
- `control_type`: A filter that narrows the list of controls to a specific type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"controlCatalogId"`: A filter that narrows the list of controls to a specific resource
from the Amazon Web Services Control Catalog. To use this parameter, specify the ARN of
the Control Catalog resource. You can specify either a control domain, a control objective,
or a common control. For information about how to find the ARNs for these resources, see
ListDomains , ListObjectives , and ListCommonControls . You can only filter by one
Control Catalog resource at a time. Specifying multiple resource ARNs isn’t currently
supported. If you want to filter by more than one ARN, we recommend that you run the
ListControls operation separately for each ARN. Alternatively, specify UNCATEGORIZED to
list controls that aren't mapped to a Control Catalog resource. For example, this operation
might return a list of custom controls that don't belong to any control domain or control
objective.
- `"maxResults"`: The maximum number of results on a page or for an API request call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_controls(controlType; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET",
"/controls",
Dict{String,Any}("controlType" => controlType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_controls(
controlType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/controls",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("controlType" => controlType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_keywords_for_data_source(source)
list_keywords_for_data_source(source, params::Dict{String,<:Any})
Returns a list of keywords that are pre-mapped to the specified control data source.
# Arguments
- `source`: The control mapping data source that the keywords apply to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_keywords_for_data_source(
source; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/dataSourceKeywords",
Dict{String,Any}("source" => source);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_keywords_for_data_source(
source, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/dataSourceKeywords",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("source" => source), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_notifications()
list_notifications(params::Dict{String,<:Any})
Returns a list of all Audit Manager notifications.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Represents the maximum number of results on a page or for an API request
call.
- `"nextToken"`: The pagination token that's used to fetch the next set of results.
"""
function list_notifications(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"GET", "/notifications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_notifications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/notifications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for the specified resource in Audit Manager.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_account()
register_account(params::Dict{String,<:Any})
Enables Audit Manager for the specified Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"delegatedAdminAccount"`: The delegated administrator account for Audit Manager.
- `"kmsKey"`: The KMS key details.
"""
function register_account(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"POST",
"/account/registerAccount";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_account(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/account/registerAccount",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_organization_admin_account(admin_account_id)
register_organization_admin_account(admin_account_id, params::Dict{String,<:Any})
Enables an Amazon Web Services account within the organization as the delegated
administrator for Audit Manager.
# Arguments
- `admin_account_id`: The identifier for the delegated administrator account.
"""
function register_organization_admin_account(
adminAccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/account/registerOrganizationAdminAccount",
Dict{String,Any}("adminAccountId" => adminAccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_organization_admin_account(
adminAccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/account/registerOrganizationAdminAccount",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("adminAccountId" => adminAccountId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_assessment_framework_share(destination_account, destination_region, framework_id)
start_assessment_framework_share(destination_account, destination_region, framework_id, params::Dict{String,<:Any})
Creates a share request for a custom framework in Audit Manager. The share request
specifies a recipient and notifies them that a custom framework is available. Recipients
have 120 days to accept or decline the request. If no action is taken, the share request
expires. When you create a share request, Audit Manager stores a snapshot of your custom
framework in the US East (N. Virginia) Amazon Web Services Region. Audit Manager also
stores a backup of the same snapshot in the US West (Oregon) Amazon Web Services Region.
Audit Manager deletes the snapshot and the backup snapshot when one of the following events
occurs: The sender revokes the share request. The recipient declines the share request.
The recipient encounters an error and doesn't successfully accept the share request.
The share request expires before the recipient responds to the request. When a sender
resends a share request, the snapshot is replaced with an updated version that corresponds
with the latest version of the custom framework. When a recipient accepts a share request,
the snapshot is replicated into their Amazon Web Services account under the Amazon Web
Services Region that was specified in the share request. When you invoke the
StartAssessmentFrameworkShare API, you are about to share a custom framework with another
Amazon Web Services account. You may not share a custom framework that is derived from a
standard framework if the standard framework is designated as not eligible for sharing by
Amazon Web Services, unless you have obtained permission to do so from the owner of the
standard framework. To learn more about which standard frameworks are eligible for sharing,
see Framework sharing eligibility in the Audit Manager User Guide.
# Arguments
- `destination_account`: The Amazon Web Services account of the recipient.
- `destination_region`: The Amazon Web Services Region of the recipient.
- `framework_id`: The unique identifier for the custom framework to be shared.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"comment"`: An optional comment from the sender about the share request.
"""
function start_assessment_framework_share(
destinationAccount,
destinationRegion,
frameworkId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessmentFrameworks/$(frameworkId)/shareRequests",
Dict{String,Any}(
"destinationAccount" => destinationAccount,
"destinationRegion" => destinationRegion,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_assessment_framework_share(
destinationAccount,
destinationRegion,
frameworkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessmentFrameworks/$(frameworkId)/shareRequests",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationAccount" => destinationAccount,
"destinationRegion" => destinationRegion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tags the specified resource in Audit Manager.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
- `tags`: The tags that are associated with the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag from a resource in Audit Manager.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the specified resource.
- `tag_keys`: The name or key of the tag.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment(assessment_id, scope)
update_assessment(assessment_id, scope, params::Dict{String,<:Any})
Edits an Audit Manager assessment.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `scope`: The scope of the assessment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"assessmentDescription"`: The description of the assessment.
- `"assessmentName"`: The name of the assessment to be updated.
- `"assessmentReportsDestination"`: The assessment report storage destination for the
assessment that's being updated.
- `"roles"`: The list of roles for the assessment.
"""
function update_assessment(
assessmentId, scope; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)",
Dict{String,Any}("scope" => scope);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment(
assessmentId,
scope,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("scope" => scope), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment_control(assessment_id, control_id, control_set_id)
update_assessment_control(assessment_id, control_id, control_set_id, params::Dict{String,<:Any})
Updates a control within an assessment in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `control_id`: The unique identifier for the control.
- `control_set_id`: The unique identifier for the control set.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commentBody"`: The comment body text for the control.
- `"controlStatus"`: The status of the control.
"""
function update_assessment_control(
assessmentId, controlId, controlSetId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/controls/$(controlId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment_control(
assessmentId,
controlId,
controlSetId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/controls/$(controlId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment_control_set_status(assessment_id, comment, control_set_id, status)
update_assessment_control_set_status(assessment_id, comment, control_set_id, status, params::Dict{String,<:Any})
Updates the status of a control set in an Audit Manager assessment.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `comment`: The comment that's related to the status update.
- `control_set_id`: The unique identifier for the control set.
- `status`: The status of the control set that's being updated.
"""
function update_assessment_control_set_status(
assessmentId,
comment,
controlSetId,
status;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/status",
Dict{String,Any}("comment" => comment, "status" => status);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment_control_set_status(
assessmentId,
comment,
controlSetId,
status,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/controlSets/$(controlSetId)/status",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("comment" => comment, "status" => status), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment_framework(control_sets, framework_id, name)
update_assessment_framework(control_sets, framework_id, name, params::Dict{String,<:Any})
Updates a custom framework in Audit Manager.
# Arguments
- `control_sets`: The control sets that are associated with the framework.
- `framework_id`: The unique identifier for the framework.
- `name`: The name of the framework to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"complianceType"`: The compliance type that the new custom framework supports, such as
CIS or HIPAA.
- `"description"`: The description of the updated framework.
"""
function update_assessment_framework(
controlSets, frameworkId, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessmentFrameworks/$(frameworkId)",
Dict{String,Any}("controlSets" => controlSets, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment_framework(
controlSets,
frameworkId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessmentFrameworks/$(frameworkId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("controlSets" => controlSets, "name" => name),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment_framework_share(action, request_id, request_type)
update_assessment_framework_share(action, request_id, request_type, params::Dict{String,<:Any})
Updates a share request for a custom framework in Audit Manager.
# Arguments
- `action`: Specifies the update action for the share request.
- `request_id`: The unique identifier for the share request.
- `request_type`: Specifies whether the share request is a sent request or a received
request.
"""
function update_assessment_framework_share(
action, requestId, requestType; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessmentFrameworkShareRequests/$(requestId)",
Dict{String,Any}("action" => action, "requestType" => requestType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment_framework_share(
action,
requestId,
requestType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessmentFrameworkShareRequests/$(requestId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("action" => action, "requestType" => requestType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_assessment_status(assessment_id, status)
update_assessment_status(assessment_id, status, params::Dict{String,<:Any})
Updates the status of an assessment in Audit Manager.
# Arguments
- `assessment_id`: The unique identifier for the assessment.
- `status`: The current status of the assessment.
"""
function update_assessment_status(
assessmentId, status; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/status",
Dict{String,Any}("status" => status);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_assessment_status(
assessmentId,
status,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/assessments/$(assessmentId)/status",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("status" => status), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_control(control_id, control_mapping_sources, name)
update_control(control_id, control_mapping_sources, name, params::Dict{String,<:Any})
Updates a custom control in Audit Manager.
# Arguments
- `control_id`: The identifier for the control.
- `control_mapping_sources`: The data mapping sources for the control.
- `name`: The name of the updated control.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actionPlanInstructions"`: The recommended actions to carry out if the control isn't
fulfilled.
- `"actionPlanTitle"`: The title of the action plan for remediating the control.
- `"description"`: The optional description of the control.
- `"testingInformation"`: The steps that you should follow to determine if the control is
met.
"""
function update_control(
controlId,
controlMappingSources,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/controls/$(controlId)",
Dict{String,Any}("controlMappingSources" => controlMappingSources, "name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_control(
controlId,
controlMappingSources,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"PUT",
"/controls/$(controlId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"controlMappingSources" => controlMappingSources, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_settings()
update_settings(params::Dict{String,<:Any})
Updates Audit Manager settings for the current account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"defaultAssessmentReportsDestination"`: The default S3 destination bucket for storing
assessment reports.
- `"defaultExportDestination"`: The default S3 destination bucket for storing evidence
finder exports.
- `"defaultProcessOwners"`: A list of the default audit owners.
- `"deregistrationPolicy"`: The deregistration policy for your Audit Manager data. You can
use this attribute to determine how your data is handled when you deregister Audit Manager.
- `"evidenceFinderEnabled"`: Specifies whether the evidence finder feature is enabled.
Change this attribute to enable or disable evidence finder. When you use this attribute to
disable evidence finder, Audit Manager deletes the event data store that’s used to query
your evidence data. As a result, you can’t re-enable evidence finder and use the feature
again. Your only alternative is to deregister and then re-register Audit Manager.
- `"kmsKey"`: The KMS key details.
- `"snsTopic"`: The Amazon Simple Notification Service (Amazon SNS) topic that Audit
Manager sends notifications to.
"""
function update_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return auditmanager(
"PUT", "/settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"PUT", "/settings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
validate_assessment_report_integrity(s3_relative_path)
validate_assessment_report_integrity(s3_relative_path, params::Dict{String,<:Any})
Validates the integrity of an assessment report in Audit Manager.
# Arguments
- `s3_relative_path`: The relative path of the Amazon S3 bucket that the assessment report
is stored in.
"""
function validate_assessment_report_integrity(
s3RelativePath; aws_config::AbstractAWSConfig=global_aws_config()
)
return auditmanager(
"POST",
"/assessmentReports/integrity",
Dict{String,Any}("s3RelativePath" => s3RelativePath);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function validate_assessment_report_integrity(
s3RelativePath,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auditmanager(
"POST",
"/assessmentReports/integrity",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("s3RelativePath" => s3RelativePath), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 158983 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: auto_scaling
using AWS.Compat
using AWS.UUIDs
"""
attach_instances(auto_scaling_group_name)
attach_instances(auto_scaling_group_name, params::Dict{String,<:Any})
Attaches one or more EC2 instances to the specified Auto Scaling group. When you attach
instances, Amazon EC2 Auto Scaling increases the desired capacity of the group by the
number of instances being attached. If the number of instances being attached plus the
desired capacity of the group exceeds the maximum size of the group, the operation fails.
If there is a Classic Load Balancer attached to your Auto Scaling group, the instances are
also registered with the load balancer. If there are target groups attached to your Auto
Scaling group, the instances are also registered with the target groups. For more
information, see Detach or attach instances in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceIds"`: The IDs of the instances. You can specify up to 20 instances.
"""
function attach_instances(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"AttachInstances",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_instances(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"AttachInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_load_balancer_target_groups(auto_scaling_group_name, target_group_arns)
attach_load_balancer_target_groups(auto_scaling_group_name, target_group_arns, params::Dict{String,<:Any})
This API operation is superseded by AttachTrafficSources, which can attach multiple
traffic sources types. We recommend using AttachTrafficSources to simplify how you manage
traffic sources. However, we continue to support AttachLoadBalancerTargetGroups. You can
use both the original AttachLoadBalancerTargetGroups API operation and AttachTrafficSources
on the same Auto Scaling group. Attaches one or more target groups to the specified Auto
Scaling group. This operation is used with the following load balancer types:
Application Load Balancer - Operates at the application layer (layer 7) and supports HTTP
and HTTPS. Network Load Balancer - Operates at the transport layer (layer 4) and
supports TCP, TLS, and UDP. Gateway Load Balancer - Operates at the network layer (layer
3). To describe the target groups for an Auto Scaling group, call the
DescribeLoadBalancerTargetGroups API. To detach the target group from the Auto Scaling
group, call the DetachLoadBalancerTargetGroups API. This operation is additive and does not
detach existing target groups or Classic Load Balancers from the Auto Scaling group. For
more information, see Use Elastic Load Balancing to distribute traffic across the instances
in your Auto Scaling group in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `target_group_arns`: The Amazon Resource Names (ARNs) of the target groups. You can
specify up to 10 target groups. To get the ARN of a target group, use the Elastic Load
Balancing DescribeTargetGroups API operation.
"""
function attach_load_balancer_target_groups(
AutoScalingGroupName, TargetGroupARNs; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"AttachLoadBalancerTargetGroups",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TargetGroupARNs" => TargetGroupARNs,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_load_balancer_target_groups(
AutoScalingGroupName,
TargetGroupARNs,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"AttachLoadBalancerTargetGroups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TargetGroupARNs" => TargetGroupARNs,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_load_balancers(auto_scaling_group_name, load_balancer_names)
attach_load_balancers(auto_scaling_group_name, load_balancer_names, params::Dict{String,<:Any})
This API operation is superseded by AttachTrafficSources, which can attach multiple
traffic sources types. We recommend using AttachTrafficSources to simplify how you manage
traffic sources. However, we continue to support AttachLoadBalancers. You can use both the
original AttachLoadBalancers API operation and AttachTrafficSources on the same Auto
Scaling group. Attaches one or more Classic Load Balancers to the specified Auto Scaling
group. Amazon EC2 Auto Scaling registers the running instances with these Classic Load
Balancers. To describe the load balancers for an Auto Scaling group, call the
DescribeLoadBalancers API. To detach a load balancer from the Auto Scaling group, call the
DetachLoadBalancers API. This operation is additive and does not detach existing Classic
Load Balancers or target groups from the Auto Scaling group. For more information, see Use
Elastic Load Balancing to distribute traffic across the instances in your Auto Scaling
group in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `load_balancer_names`: The names of the load balancers. You can specify up to 10 load
balancers.
"""
function attach_load_balancers(
AutoScalingGroupName,
LoadBalancerNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"AttachLoadBalancers",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LoadBalancerNames" => LoadBalancerNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_load_balancers(
AutoScalingGroupName,
LoadBalancerNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"AttachLoadBalancers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LoadBalancerNames" => LoadBalancerNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_traffic_sources(auto_scaling_group_name, traffic_sources)
attach_traffic_sources(auto_scaling_group_name, traffic_sources, params::Dict{String,<:Any})
Attaches one or more traffic sources to the specified Auto Scaling group. You can use any
of the following as traffic sources for an Auto Scaling group: Application Load Balancer
Classic Load Balancer Gateway Load Balancer Network Load Balancer VPC Lattice This
operation is additive and does not detach existing traffic sources from the Auto Scaling
group. After the operation completes, use the DescribeTrafficSources API to return details
about the state of the attachments between traffic sources and your Auto Scaling group. To
detach a traffic source from the Auto Scaling group, call the DetachTrafficSources API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `traffic_sources`: The unique identifiers of one or more traffic sources. You can specify
up to 10 traffic sources.
"""
function attach_traffic_sources(
AutoScalingGroupName, TrafficSources; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"AttachTrafficSources",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TrafficSources" => TrafficSources,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_traffic_sources(
AutoScalingGroupName,
TrafficSources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"AttachTrafficSources",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TrafficSources" => TrafficSources,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_scheduled_action(auto_scaling_group_name, scheduled_action_names)
batch_delete_scheduled_action(auto_scaling_group_name, scheduled_action_names, params::Dict{String,<:Any})
Deletes one or more scheduled actions for the specified Auto Scaling group.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `scheduled_action_names`: The names of the scheduled actions to delete. The maximum
number allowed is 50.
"""
function batch_delete_scheduled_action(
AutoScalingGroupName,
ScheduledActionNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"BatchDeleteScheduledAction",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionNames" => ScheduledActionNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_scheduled_action(
AutoScalingGroupName,
ScheduledActionNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"BatchDeleteScheduledAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionNames" => ScheduledActionNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_put_scheduled_update_group_action(auto_scaling_group_name, scheduled_update_group_actions)
batch_put_scheduled_update_group_action(auto_scaling_group_name, scheduled_update_group_actions, params::Dict{String,<:Any})
Creates or updates one or more scheduled scaling actions for an Auto Scaling group.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `scheduled_update_group_actions`: One or more scheduled actions. The maximum number
allowed is 50.
"""
function batch_put_scheduled_update_group_action(
AutoScalingGroupName,
ScheduledUpdateGroupActions;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"BatchPutScheduledUpdateGroupAction",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledUpdateGroupActions" => ScheduledUpdateGroupActions,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_put_scheduled_update_group_action(
AutoScalingGroupName,
ScheduledUpdateGroupActions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"BatchPutScheduledUpdateGroupAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledUpdateGroupActions" => ScheduledUpdateGroupActions,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_instance_refresh(auto_scaling_group_name)
cancel_instance_refresh(auto_scaling_group_name, params::Dict{String,<:Any})
Cancels an instance refresh or rollback that is in progress. If an instance refresh or
rollback is not in progress, an ActiveInstanceRefreshNotFound error occurs. This operation
is part of the instance refresh feature in Amazon EC2 Auto Scaling, which helps you update
instances in your Auto Scaling group after you make configuration changes. When you cancel
an instance refresh, this does not roll back any changes that it made. Use the
RollbackInstanceRefresh API to roll back instead.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
"""
function cancel_instance_refresh(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"CancelInstanceRefresh",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_instance_refresh(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CancelInstanceRefresh",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
complete_lifecycle_action(auto_scaling_group_name, lifecycle_action_result, lifecycle_hook_name)
complete_lifecycle_action(auto_scaling_group_name, lifecycle_action_result, lifecycle_hook_name, params::Dict{String,<:Any})
Completes the lifecycle action for the specified token or instance with the specified
result. This step is a part of the procedure for adding a lifecycle hook to an Auto Scaling
group: (Optional) Create a launch template or launch configuration with a user data
script that runs while an instance is in a wait state due to a lifecycle hook. (Optional)
Create a Lambda function and a rule that allows Amazon EventBridge to invoke your Lambda
function when an instance is put into a wait state due to a lifecycle hook. (Optional)
Create a notification target and an IAM role. The target can be either an Amazon SQS queue
or an Amazon SNS topic. The role allows Amazon EC2 Auto Scaling to publish lifecycle
notifications to the target. Create the lifecycle hook. Specify whether the hook is used
when the instances launch or terminate. If you need more time, record the lifecycle
action heartbeat to keep the instance in a wait state. If you finish before the timeout
period ends, send a callback by using the CompleteLifecycleAction API call. For more
information, see Complete a lifecycle action in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `lifecycle_action_result`: The action for the group to take. You can specify either
CONTINUE or ABANDON.
- `lifecycle_hook_name`: The name of the lifecycle hook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceId"`: The ID of the instance.
- `"LifecycleActionToken"`: A universally unique identifier (UUID) that identifies a
specific lifecycle action associated with an instance. Amazon EC2 Auto Scaling sends this
token to the notification target you specified when you created the lifecycle hook.
"""
function complete_lifecycle_action(
AutoScalingGroupName,
LifecycleActionResult,
LifecycleHookName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CompleteLifecycleAction",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleActionResult" => LifecycleActionResult,
"LifecycleHookName" => LifecycleHookName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function complete_lifecycle_action(
AutoScalingGroupName,
LifecycleActionResult,
LifecycleHookName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CompleteLifecycleAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleActionResult" => LifecycleActionResult,
"LifecycleHookName" => LifecycleHookName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_auto_scaling_group(auto_scaling_group_name, max_size, min_size)
create_auto_scaling_group(auto_scaling_group_name, max_size, min_size, params::Dict{String,<:Any})
We strongly recommend using a launch template when calling this operation to ensure full
functionality for Amazon EC2 Auto Scaling and Amazon EC2. Creates an Auto Scaling group
with the specified name and attributes. If you exceed your maximum limit of Auto Scaling
groups, the call fails. To query this limit, call the DescribeAccountLimits API. For
information about updating this limit, see Quotas for Amazon EC2 Auto Scaling in the Amazon
EC2 Auto Scaling User Guide. If you're new to Amazon EC2 Auto Scaling, see the introductory
tutorials in Get started with Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User
Guide. Every Auto Scaling group has three size properties (DesiredCapacity, MaxSize, and
MinSize). Usually, you set these sizes based on a specific number of instances. However, if
you configure a mixed instances policy that defines weights for the instance types, you
must specify these sizes with the same units that you use for weighting instances.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group. This name must be unique
per Region per account. The name can contain any ASCII character 33 to 126 including most
punctuation characters, digits, and upper and lowercased letters. You cannot use a colon
(:) in the name.
- `max_size`: The maximum size of the group. With a mixed instances policy that uses
instance weighting, Amazon EC2 Auto Scaling may need to go above MaxSize to meet your
capacity requirements. In this event, Amazon EC2 Auto Scaling will never go above MaxSize
by more than your largest instance weight (weights that define how many units each instance
contributes to the desired capacity of the group).
- `min_size`: The minimum size of the group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AvailabilityZones"`: A list of Availability Zones where instances in the Auto Scaling
group can be created. Used for launching into the default VPC subnet in each Availability
Zone when not using the VPCZoneIdentifier property, or for attaching a network interface
when an existing network interface ID is specified in a launch template.
- `"CapacityRebalance"`: Indicates whether Capacity Rebalancing is enabled. Otherwise,
Capacity Rebalancing is disabled. When you turn on Capacity Rebalancing, Amazon EC2 Auto
Scaling attempts to launch a Spot Instance whenever Amazon EC2 notifies that a Spot
Instance is at an elevated risk of interruption. After launching a new instance, it then
terminates an old instance. For more information, see Use Capacity Rebalancing to handle
Amazon EC2 Spot Interruptions in the in the Amazon EC2 Auto Scaling User Guide.
- `"Context"`: Reserved.
- `"DefaultCooldown"`: Only needed if you use simple scaling policies. The amount of
time, in seconds, between one scaling activity ending and another one starting due to
simple scaling policies. For more information, see Scaling cooldowns for Amazon EC2 Auto
Scaling in the Amazon EC2 Auto Scaling User Guide. Default: 300 seconds
- `"DefaultInstanceWarmup"`: The amount of time, in seconds, until a new instance is
considered to have finished initializing and resource consumption to become stable after it
enters the InService state. During an instance refresh, Amazon EC2 Auto Scaling waits for
the warm-up period after it replaces an instance before it moves on to replacing the next
instance. Amazon EC2 Auto Scaling also waits for the warm-up period before aggregating the
metrics for new instances with existing instances in the Amazon CloudWatch metrics that are
used for scaling, resulting in more reliable usage data. For more information, see Set the
default instance warmup for an Auto Scaling group in the Amazon EC2 Auto Scaling User
Guide. To manage various warm-up settings at the group level, we recommend that you set
the default instance warmup, even if it is set to 0 seconds. To remove a value that you
previously set, include the property but specify -1 for the value. However, we strongly
recommend keeping the default instance warmup enabled by specifying a value of 0 or other
nominal value. Default: None
- `"DesiredCapacity"`: The desired capacity is the initial capacity of the Auto Scaling
group at the time of its creation and the capacity it attempts to maintain. It can scale
beyond this capacity if you configure auto scaling. This number must be greater than or
equal to the minimum size of the group and less than or equal to the maximum size of the
group. If you do not specify a desired capacity, the default is the minimum size of the
group.
- `"DesiredCapacityType"`: The unit of measurement for the value specified for desired
capacity. Amazon EC2 Auto Scaling supports DesiredCapacityType for attribute-based instance
type selection only. For more information, see Create a mixed instances group using
attribute-based instance type selection in the Amazon EC2 Auto Scaling User Guide. By
default, Amazon EC2 Auto Scaling specifies units, which translates into number of
instances. Valid values: units | vcpu | memory-mib
- `"HealthCheckGracePeriod"`: The amount of time, in seconds, that Amazon EC2 Auto Scaling
waits before checking the health status of an EC2 instance that has come into service and
marking it unhealthy due to a failed health check. This is useful if your instances do not
immediately pass their health checks after they enter the InService state. For more
information, see Set the health check grace period for an Auto Scaling group in the Amazon
EC2 Auto Scaling User Guide. Default: 0 seconds
- `"HealthCheckType"`: A comma-separated value string of one or more health check types.
The valid values are EC2, ELB, and VPC_LATTICE. EC2 is the default health check and cannot
be disabled. For more information, see Health checks for instances in an Auto Scaling group
in the Amazon EC2 Auto Scaling User Guide. Only specify EC2 if you must clear a value that
was previously set.
- `"InstanceId"`: The ID of the instance used to base the launch configuration on. If
specified, Amazon EC2 Auto Scaling uses the configuration values from the specified
instance to create a new launch configuration. To get the instance ID, use the Amazon EC2
DescribeInstances API operation. For more information, see Create an Auto Scaling group
using parameters from an existing instance in the Amazon EC2 Auto Scaling User Guide.
- `"InstanceMaintenancePolicy"`: An instance maintenance policy. For more information, see
Set instance maintenance policy in the Amazon EC2 Auto Scaling User Guide.
- `"LaunchConfigurationName"`: The name of the launch configuration to use to launch
instances. Conditional: You must specify either a launch template (LaunchTemplate or
MixedInstancesPolicy) or a launch configuration (LaunchConfigurationName or InstanceId).
- `"LaunchTemplate"`: Information used to specify the launch template and version to use to
launch instances. Conditional: You must specify either a launch template (LaunchTemplate
or MixedInstancesPolicy) or a launch configuration (LaunchConfigurationName or InstanceId).
The launch template that is specified must be configured for use with an Auto Scaling
group. For more information, see Create a launch template for an Auto Scaling group in the
Amazon EC2 Auto Scaling User Guide.
- `"LifecycleHookSpecificationList"`: One or more lifecycle hooks to add to the Auto
Scaling group before instances are launched.
- `"LoadBalancerNames"`: A list of Classic Load Balancers associated with this Auto Scaling
group. For Application Load Balancers, Network Load Balancers, and Gateway Load Balancers,
specify the TargetGroupARNs property instead.
- `"MaxInstanceLifetime"`: The maximum amount of time, in seconds, that an instance can be
in service. The default is null. If specified, the value must be either 0 or a number equal
to or greater than 86,400 seconds (1 day). For more information, see Replace Auto Scaling
instances based on maximum instance lifetime in the Amazon EC2 Auto Scaling User Guide.
- `"MixedInstancesPolicy"`: The mixed instances policy. For more information, see Auto
Scaling groups with multiple instance types and purchase options in the Amazon EC2 Auto
Scaling User Guide.
- `"NewInstancesProtectedFromScaleIn"`: Indicates whether newly launched instances are
protected from termination by Amazon EC2 Auto Scaling when scaling in. For more information
about preventing instances from terminating on scale in, see Use instance scale-in
protection in the Amazon EC2 Auto Scaling User Guide.
- `"PlacementGroup"`: The name of the placement group into which to launch your instances.
For more information, see Placement groups in the Amazon EC2 User Guide for Linux
Instances. A cluster placement group is a logical grouping of instances within a single
Availability Zone. You cannot specify multiple Availability Zones and a cluster placement
group.
- `"ServiceLinkedRoleARN"`: The Amazon Resource Name (ARN) of the service-linked role that
the Auto Scaling group uses to call other Amazon Web Services service on your behalf. By
default, Amazon EC2 Auto Scaling uses a service-linked role named
AWSServiceRoleForAutoScaling, which it creates if it does not exist. For more information,
see Service-linked roles in the Amazon EC2 Auto Scaling User Guide.
- `"Tags"`: One or more tags. You can tag your Auto Scaling group and propagate the tags to
the Amazon EC2 instances it launches. Tags are not propagated to Amazon EBS volumes. To add
tags to Amazon EBS volumes, specify the tags in a launch template but use caution. If the
launch template specifies an instance tag with a key that is also specified for the Auto
Scaling group, Amazon EC2 Auto Scaling overrides the value of that instance tag with the
value specified by the Auto Scaling group. For more information, see Tag Auto Scaling
groups and instances in the Amazon EC2 Auto Scaling User Guide.
- `"TargetGroupARNs"`: The Amazon Resource Names (ARN) of the Elastic Load Balancing target
groups to associate with the Auto Scaling group. Instances are registered as targets with
the target groups. The target groups receive incoming traffic and route requests to one or
more registered targets. For more information, see Use Elastic Load Balancing to distribute
traffic across the instances in your Auto Scaling group in the Amazon EC2 Auto Scaling User
Guide.
- `"TerminationPolicies"`: A policy or a list of policies that are used to select the
instance to terminate. These policies are executed in the order that you list them. For
more information, see Configure termination policies for Amazon EC2 Auto Scaling in the
Amazon EC2 Auto Scaling User Guide. Valid values: Default | AllocationStrategy |
ClosestToNextInstanceHour | NewestInstance | OldestInstance | OldestLaunchConfiguration |
OldestLaunchTemplate | arn:aws:lambda:region:account-id:function:my-function:my-alias
- `"TrafficSources"`: The list of traffic sources to attach to this Auto Scaling group. You
can use any of the following as traffic sources for an Auto Scaling group: Classic Load
Balancer, Application Load Balancer, Gateway Load Balancer, Network Load Balancer, and VPC
Lattice.
- `"VPCZoneIdentifier"`: A comma-separated list of subnet IDs for a virtual private cloud
(VPC) where instances in the Auto Scaling group can be created. If you specify
VPCZoneIdentifier with AvailabilityZones, the subnets that you specify must reside in those
Availability Zones.
"""
function create_auto_scaling_group(
AutoScalingGroupName,
MaxSize,
MinSize;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CreateAutoScalingGroup",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"MaxSize" => MaxSize,
"MinSize" => MinSize,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_auto_scaling_group(
AutoScalingGroupName,
MaxSize,
MinSize,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CreateAutoScalingGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"MaxSize" => MaxSize,
"MinSize" => MinSize,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_launch_configuration(launch_configuration_name)
create_launch_configuration(launch_configuration_name, params::Dict{String,<:Any})
Creates a launch configuration. If you exceed your maximum limit of launch configurations,
the call fails. To query this limit, call the DescribeAccountLimits API. For information
about updating this limit, see Quotas for Amazon EC2 Auto Scaling in the Amazon EC2 Auto
Scaling User Guide. For more information, see Launch configurations in the Amazon EC2 Auto
Scaling User Guide. Amazon EC2 Auto Scaling configures instances launched as part of an
Auto Scaling group using either a launch template or a launch configuration. We strongly
recommend that you do not use launch configurations. They do not provide full functionality
for Amazon EC2 Auto Scaling or Amazon EC2. For information about using launch templates,
see Launch templates in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `launch_configuration_name`: The name of the launch configuration. This name must be
unique per Region per account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AssociatePublicIpAddress"`: Specifies whether to assign a public IPv4 address to the
group's instances. If the instance is launched into a default subnet, the default is to
assign a public IPv4 address, unless you disabled the option to assign a public IPv4
address on the subnet. If the instance is launched into a nondefault subnet, the default is
not to assign a public IPv4 address, unless you enabled the option to assign a public IPv4
address on the subnet. If you specify true, each instance in the Auto Scaling group
receives a unique public IPv4 address. For more information, see Provide network
connectivity for your Auto Scaling instances using Amazon VPC in the Amazon EC2 Auto
Scaling User Guide. If you specify this property, you must specify at least one subnet for
VPCZoneIdentifier when you create your group.
- `"BlockDeviceMappings"`: The block device mapping entries that define the block devices
to attach to the instances at launch. By default, the block devices specified in the block
device mapping for the AMI are used. For more information, see Block device mappings in the
Amazon EC2 User Guide for Linux Instances.
- `"ClassicLinkVPCId"`: Available for backward compatibility.
- `"ClassicLinkVPCSecurityGroups"`: Available for backward compatibility.
- `"EbsOptimized"`: Specifies whether the launch configuration is optimized for EBS I/O
(true) or not (false). The optimization provides dedicated throughput to Amazon EBS and an
optimized configuration stack to provide optimal I/O performance. This optimization is not
available with all instance types. Additional fees are incurred when you enable EBS
optimization for an instance type that is not EBS-optimized by default. For more
information, see Amazon EBS-optimized instances in the Amazon EC2 User Guide for Linux
Instances. The default value is false.
- `"IamInstanceProfile"`: The name or the Amazon Resource Name (ARN) of the instance
profile associated with the IAM role for the instance. The instance profile contains the
IAM role. For more information, see IAM role for applications that run on Amazon EC2
instances in the Amazon EC2 Auto Scaling User Guide.
- `"ImageId"`: The ID of the Amazon Machine Image (AMI) that was assigned during
registration. For more information, see Find a Linux AMI in the Amazon EC2 User Guide for
Linux Instances. If you specify InstanceId, an ImageId is not required.
- `"InstanceId"`: The ID of the instance to use to create the launch configuration. The new
launch configuration derives attributes from the instance, except for the block device
mapping. To create a launch configuration with a block device mapping or override any other
instance attributes, specify them as part of the same request. For more information, see
Create a launch configuration in the Amazon EC2 Auto Scaling User Guide.
- `"InstanceMonitoring"`: Controls whether instances in this group are launched with
detailed (true) or basic (false) monitoring. The default value is true (enabled). When
detailed monitoring is enabled, Amazon CloudWatch generates metrics every minute and your
account is charged a fee. When you disable detailed monitoring, CloudWatch generates
metrics every 5 minutes. For more information, see Configure monitoring for Auto Scaling
instances in the Amazon EC2 Auto Scaling User Guide.
- `"InstanceType"`: Specifies the instance type of the EC2 instance. For information about
available instance types, see Available instance types in the Amazon EC2 User Guide for
Linux Instances. If you specify InstanceId, an InstanceType is not required.
- `"KernelId"`: The ID of the kernel associated with the AMI. We recommend that you use
PV-GRUB instead of kernels and RAM disks. For more information, see User provided kernels
in the Amazon EC2 User Guide for Linux Instances.
- `"KeyName"`: The name of the key pair. For more information, see Amazon EC2 key pairs and
Amazon EC2 instances in the Amazon EC2 User Guide for Linux Instances.
- `"MetadataOptions"`: The metadata options for the instances. For more information, see
Configure the instance metadata options in the Amazon EC2 Auto Scaling User Guide.
- `"PlacementTenancy"`: The tenancy of the instance, either default or dedicated. An
instance with dedicated tenancy runs on isolated, single-tenant hardware and can only be
launched into a VPC. To launch dedicated instances into a shared tenancy VPC (a VPC with
the instance placement tenancy attribute set to default), you must set the value of this
property to dedicated. If you specify PlacementTenancy, you must specify at least one
subnet for VPCZoneIdentifier when you create your group. Valid values: default | dedicated
- `"RamdiskId"`: The ID of the RAM disk to select. We recommend that you use PV-GRUB
instead of kernels and RAM disks. For more information, see User provided kernels in the
Amazon EC2 User Guide for Linux Instances.
- `"SecurityGroups"`: A list that contains the security group IDs to assign to the
instances in the Auto Scaling group. For more information, see Control traffic to your
Amazon Web Services resources using security groups in the Amazon Virtual Private Cloud
User Guide.
- `"SpotPrice"`: The maximum hourly price to be paid for any Spot Instance launched to
fulfill the request. Spot Instances are launched when the price you specify exceeds the
current Spot price. For more information, see Request Spot Instances for fault-tolerant and
flexible applications in the Amazon EC2 Auto Scaling User Guide. Valid Range: Minimum value
of 0.001 When you change your maximum price by creating a new launch configuration,
running instances will continue to run as long as the maximum price for those running
instances is higher than the current Spot price.
- `"UserData"`: The user data to make available to the launched EC2 instances. For more
information, see Instance metadata and user data (Linux) and Instance metadata and user
data (Windows). If you are using a command line tool, base64-encoding is performed for you,
and you can load the text from a file. Otherwise, you must provide base64-encoded text.
User data is limited to 16 KB.
"""
function create_launch_configuration(
LaunchConfigurationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"CreateLaunchConfiguration",
Dict{String,Any}("LaunchConfigurationName" => LaunchConfigurationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_launch_configuration(
LaunchConfigurationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"CreateLaunchConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("LaunchConfigurationName" => LaunchConfigurationName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_or_update_tags(tags)
create_or_update_tags(tags, params::Dict{String,<:Any})
Creates or updates tags for the specified Auto Scaling group. When you specify a tag with a
key that already exists, the operation overwrites the previous tag definition, and you do
not get an error message. For more information, see Tag Auto Scaling groups and instances
in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `tags`: One or more tags.
"""
function create_or_update_tags(Tags; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"CreateOrUpdateTags",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_or_update_tags(
Tags, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"CreateOrUpdateTags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_auto_scaling_group(auto_scaling_group_name)
delete_auto_scaling_group(auto_scaling_group_name, params::Dict{String,<:Any})
Deletes the specified Auto Scaling group. If the group has instances or scaling activities
in progress, you must specify the option to force the deletion in order for it to succeed.
The force delete operation will also terminate the EC2 instances. If the group has a warm
pool, the force delete option also deletes the warm pool. To remove instances from the Auto
Scaling group before deleting it, call the DetachInstances API with the list of instances
and the option to decrement the desired capacity. This ensures that Amazon EC2 Auto Scaling
does not launch replacement instances. To terminate all instances before deleting the Auto
Scaling group, call the UpdateAutoScalingGroup API and set the minimum size and desired
capacity of the Auto Scaling group to zero. If the group has scaling policies, deleting the
group deletes the policies, the underlying alarm actions, and any alarm that no longer has
an associated action. For more information, see Delete your Auto Scaling infrastructure in
the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceDelete"`: Specifies that the group is to be deleted along with all instances
associated with the group, without waiting for all instances to be terminated. This action
also deletes any outstanding lifecycle actions associated with the group.
"""
function delete_auto_scaling_group(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DeleteAutoScalingGroup",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_auto_scaling_group(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteAutoScalingGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_launch_configuration(launch_configuration_name)
delete_launch_configuration(launch_configuration_name, params::Dict{String,<:Any})
Deletes the specified launch configuration. The launch configuration must not be attached
to an Auto Scaling group. When this call completes, the launch configuration is no longer
available for use.
# Arguments
- `launch_configuration_name`: The name of the launch configuration.
"""
function delete_launch_configuration(
LaunchConfigurationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DeleteLaunchConfiguration",
Dict{String,Any}("LaunchConfigurationName" => LaunchConfigurationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_launch_configuration(
LaunchConfigurationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteLaunchConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("LaunchConfigurationName" => LaunchConfigurationName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_lifecycle_hook(auto_scaling_group_name, lifecycle_hook_name)
delete_lifecycle_hook(auto_scaling_group_name, lifecycle_hook_name, params::Dict{String,<:Any})
Deletes the specified lifecycle hook. If there are any outstanding lifecycle actions, they
are completed first (ABANDON for launching instances, CONTINUE for terminating instances).
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `lifecycle_hook_name`: The name of the lifecycle hook.
"""
function delete_lifecycle_hook(
AutoScalingGroupName,
LifecycleHookName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteLifecycleHook",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_lifecycle_hook(
AutoScalingGroupName,
LifecycleHookName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteLifecycleHook",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_notification_configuration(auto_scaling_group_name, topic_arn)
delete_notification_configuration(auto_scaling_group_name, topic_arn, params::Dict{String,<:Any})
Deletes the specified notification.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `topic_arn`: The Amazon Resource Name (ARN) of the Amazon SNS topic.
"""
function delete_notification_configuration(
AutoScalingGroupName, TopicARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DeleteNotificationConfiguration",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName, "TopicARN" => TopicARN
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_notification_configuration(
AutoScalingGroupName,
TopicARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteNotificationConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName, "TopicARN" => TopicARN
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_policy(policy_name)
delete_policy(policy_name, params::Dict{String,<:Any})
Deletes the specified scaling policy. Deleting either a step scaling policy or a simple
scaling policy deletes the underlying alarm action, but does not delete the alarm, even if
it no longer has an associated action. For more information, see Delete a scaling policy in
the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `policy_name`: The name or Amazon Resource Name (ARN) of the policy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupName"`: The name of the Auto Scaling group.
"""
function delete_policy(PolicyName; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DeletePolicy",
Dict{String,Any}("PolicyName" => PolicyName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_policy(
PolicyName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeletePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PolicyName" => PolicyName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_scheduled_action(auto_scaling_group_name, scheduled_action_name)
delete_scheduled_action(auto_scaling_group_name, scheduled_action_name, params::Dict{String,<:Any})
Deletes the specified scheduled action.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `scheduled_action_name`: The name of the action to delete.
"""
function delete_scheduled_action(
AutoScalingGroupName,
ScheduledActionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteScheduledAction",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionName" => ScheduledActionName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scheduled_action(
AutoScalingGroupName,
ScheduledActionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteScheduledAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionName" => ScheduledActionName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_tags(tags)
delete_tags(tags, params::Dict{String,<:Any})
Deletes the specified tags.
# Arguments
- `tags`: One or more tags.
"""
function delete_tags(Tags; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DeleteTags",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_tags(
Tags, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DeleteTags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_warm_pool(auto_scaling_group_name)
delete_warm_pool(auto_scaling_group_name, params::Dict{String,<:Any})
Deletes the warm pool for the specified Auto Scaling group. For more information, see Warm
pools for Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceDelete"`: Specifies that the warm pool is to be deleted along with all of its
associated instances, without waiting for all instances to be terminated. This parameter
also deletes any outstanding lifecycle actions associated with the warm pool instances.
"""
function delete_warm_pool(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DeleteWarmPool",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_warm_pool(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DeleteWarmPool",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_account_limits()
describe_account_limits(params::Dict{String,<:Any})
Describes the current Amazon EC2 Auto Scaling resource quotas for your account. When you
establish an Amazon Web Services account, the account has initial quotas on the maximum
number of Auto Scaling groups and launch configurations that you can create in a given
Region. For more information, see Quotas for Amazon EC2 Auto Scaling in the Amazon EC2 Auto
Scaling User Guide.
"""
function describe_account_limits(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeAccountLimits"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_account_limits(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAccountLimits",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_adjustment_types()
describe_adjustment_types(params::Dict{String,<:Any})
Describes the available adjustment types for step scaling and simple scaling policies. The
following adjustment types are supported: ChangeInCapacity ExactCapacity
PercentChangeInCapacity
"""
function describe_adjustment_types(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeAdjustmentTypes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_adjustment_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAdjustmentTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_auto_scaling_groups()
describe_auto_scaling_groups(params::Dict{String,<:Any})
Gets information about the Auto Scaling groups in the account and Region. If you specify
Auto Scaling group names, the output includes information for only the specified Auto
Scaling groups. If you specify filters, the output includes information for only those Auto
Scaling groups that meet the filter criteria. If you do not specify group names or filters,
the output includes information for all Auto Scaling groups. This operation also returns
information about instances in Auto Scaling groups. To retrieve information about the
instances in a warm pool, you must call the DescribeWarmPool API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupNames"`: The names of the Auto Scaling groups. By default, you can only
specify up to 50 names. You can optionally increase this limit using the MaxRecords
property. If you omit this property, all Auto Scaling groups are described.
- `"Filters"`: One or more filters to limit the results based on specific tags.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_auto_scaling_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeAutoScalingGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_auto_scaling_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAutoScalingGroups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_auto_scaling_instances()
describe_auto_scaling_instances(params::Dict{String,<:Any})
Gets information about the Auto Scaling instances in the account and Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceIds"`: The IDs of the instances. If you omit this property, all Auto Scaling
instances are described. If you specify an ID that does not exist, it is ignored with no
error. Array Members: Maximum number of 50 items.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 50.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_auto_scaling_instances(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAutoScalingInstances";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_auto_scaling_instances(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAutoScalingInstances",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_auto_scaling_notification_types()
describe_auto_scaling_notification_types(params::Dict{String,<:Any})
Describes the notification types that are supported by Amazon EC2 Auto Scaling.
"""
function describe_auto_scaling_notification_types(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAutoScalingNotificationTypes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_auto_scaling_notification_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeAutoScalingNotificationTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_instance_refreshes(auto_scaling_group_name)
describe_instance_refreshes(auto_scaling_group_name, params::Dict{String,<:Any})
Gets information about the instance refreshes for the specified Auto Scaling group from the
previous six weeks. This operation is part of the instance refresh feature in Amazon EC2
Auto Scaling, which helps you update instances in your Auto Scaling group after you make
configuration changes. To help you determine the status of an instance refresh, Amazon EC2
Auto Scaling returns information about the instance refreshes you previously initiated,
including their status, start time, end time, the percentage of the instance refresh that
is complete, and the number of instances remaining to update before the instance refresh is
complete. If a rollback is initiated while an instance refresh is in progress, Amazon EC2
Auto Scaling also returns information about the rollback of the instance refresh.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceRefreshIds"`: One or more instance refresh IDs.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_instance_refreshes(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeInstanceRefreshes",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_instance_refreshes(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeInstanceRefreshes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_launch_configurations()
describe_launch_configurations(params::Dict{String,<:Any})
Gets information about the launch configurations in the account and Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LaunchConfigurationNames"`: The launch configuration names. If you omit this property,
all launch configurations are described. Array Members: Maximum number of 50 items.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_launch_configurations(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeLaunchConfigurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_launch_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeLaunchConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_lifecycle_hook_types()
describe_lifecycle_hook_types(params::Dict{String,<:Any})
Describes the available types of lifecycle hooks. The following hook types are supported:
autoscaling:EC2_INSTANCE_LAUNCHING autoscaling:EC2_INSTANCE_TERMINATING
"""
function describe_lifecycle_hook_types(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeLifecycleHookTypes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_lifecycle_hook_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeLifecycleHookTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_lifecycle_hooks(auto_scaling_group_name)
describe_lifecycle_hooks(auto_scaling_group_name, params::Dict{String,<:Any})
Gets information about the lifecycle hooks for the specified Auto Scaling group.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LifecycleHookNames"`: The names of one or more lifecycle hooks. If you omit this
property, all lifecycle hooks are described.
"""
function describe_lifecycle_hooks(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeLifecycleHooks",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_lifecycle_hooks(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeLifecycleHooks",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_load_balancer_target_groups(auto_scaling_group_name)
describe_load_balancer_target_groups(auto_scaling_group_name, params::Dict{String,<:Any})
This API operation is superseded by DescribeTrafficSources, which can describe multiple
traffic sources types. We recommend using DetachTrafficSources to simplify how you manage
traffic sources. However, we continue to support DescribeLoadBalancerTargetGroups. You can
use both the original DescribeLoadBalancerTargetGroups API operation and
DescribeTrafficSources on the same Auto Scaling group. Gets information about the Elastic
Load Balancing target groups for the specified Auto Scaling group. To determine the
attachment status of the target group, use the State element in the response. When you
attach a target group to an Auto Scaling group, the initial State value is Adding. The
state transitions to Added after all Auto Scaling instances are registered with the target
group. If Elastic Load Balancing health checks are enabled for the Auto Scaling group, the
state transitions to InService after at least one Auto Scaling instance passes the health
check. When the target group is in the InService state, Amazon EC2 Auto Scaling can
terminate and replace any instances that are reported as unhealthy. If no registered
instances pass the health checks, the target group doesn't enter the InService state.
Target groups also have an InService state if you attach them in the CreateAutoScalingGroup
API call. If your target group state is InService, but it is not working properly, check
the scaling activities by calling DescribeScalingActivities and take any corrective actions
necessary. For help with failed health checks, see Troubleshooting Amazon EC2 Auto Scaling:
Health checks in the Amazon EC2 Auto Scaling User Guide. For more information, see Use
Elastic Load Balancing to distribute traffic across the instances in your Auto Scaling
group in the Amazon EC2 Auto Scaling User Guide. You can use this operation to describe
target groups that were attached by using AttachLoadBalancerTargetGroups, but not for
target groups that were attached by using AttachTrafficSources.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 100 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_load_balancer_target_groups(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeLoadBalancerTargetGroups",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_load_balancer_target_groups(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeLoadBalancerTargetGroups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_load_balancers(auto_scaling_group_name)
describe_load_balancers(auto_scaling_group_name, params::Dict{String,<:Any})
This API operation is superseded by DescribeTrafficSources, which can describe multiple
traffic sources types. We recommend using DescribeTrafficSources to simplify how you manage
traffic sources. However, we continue to support DescribeLoadBalancers. You can use both
the original DescribeLoadBalancers API operation and DescribeTrafficSources on the same
Auto Scaling group. Gets information about the load balancers for the specified Auto
Scaling group. This operation describes only Classic Load Balancers. If you have
Application Load Balancers, Network Load Balancers, or Gateway Load Balancers, use the
DescribeLoadBalancerTargetGroups API instead. To determine the attachment status of the
load balancer, use the State element in the response. When you attach a load balancer to an
Auto Scaling group, the initial State value is Adding. The state transitions to Added after
all Auto Scaling instances are registered with the load balancer. If Elastic Load Balancing
health checks are enabled for the Auto Scaling group, the state transitions to InService
after at least one Auto Scaling instance passes the health check. When the load balancer is
in the InService state, Amazon EC2 Auto Scaling can terminate and replace any instances
that are reported as unhealthy. If no registered instances pass the health checks, the load
balancer doesn't enter the InService state. Load balancers also have an InService state if
you attach them in the CreateAutoScalingGroup API call. If your load balancer state is
InService, but it is not working properly, check the scaling activities by calling
DescribeScalingActivities and take any corrective actions necessary. For help with failed
health checks, see Troubleshooting Amazon EC2 Auto Scaling: Health checks in the Amazon EC2
Auto Scaling User Guide. For more information, see Use Elastic Load Balancing to distribute
traffic across the instances in your Auto Scaling group in the Amazon EC2 Auto Scaling User
Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 100 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_load_balancers(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeLoadBalancers",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_load_balancers(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeLoadBalancers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_metric_collection_types()
describe_metric_collection_types(params::Dict{String,<:Any})
Describes the available CloudWatch metrics for Amazon EC2 Auto Scaling.
"""
function describe_metric_collection_types(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeMetricCollectionTypes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_metric_collection_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeMetricCollectionTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_notification_configurations()
describe_notification_configurations(params::Dict{String,<:Any})
Gets information about the Amazon SNS notifications that are configured for one or more
Auto Scaling groups.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupNames"`: The name of the Auto Scaling group.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_notification_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeNotificationConfigurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_notification_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeNotificationConfigurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_policies()
describe_policies(params::Dict{String,<:Any})
Gets information about the scaling policies in the account and Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupName"`: The name of the Auto Scaling group.
- `"MaxRecords"`: The maximum number of items to be returned with each call. The default
value is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"PolicyNames"`: The names of one or more policies. If you omit this property, all
policies are described. If a group name is provided, the results are limited to that group.
If you specify an unknown policy name, it is ignored with no error. Array Members: Maximum
number of 50 items.
- `"PolicyTypes"`: One or more policy types. The valid values are SimpleScaling,
StepScaling, TargetTrackingScaling, and PredictiveScaling.
"""
function describe_policies(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribePolicies"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_policies(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribePolicies", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_scaling_activities()
describe_scaling_activities(params::Dict{String,<:Any})
Gets information about the scaling activities in the account and Region. When scaling
events occur, you see a record of the scaling activity in the scaling activities. For more
information, see Verify a scaling activity for an Auto Scaling group in the Amazon EC2 Auto
Scaling User Guide. If the scaling event succeeds, the value of the StatusCode element in
the response is Successful. If an attempt to launch instances failed, the StatusCode value
is Failed or Cancelled and the StatusMessage element in the response indicates the cause of
the failure. For help interpreting the StatusMessage, see Troubleshooting Amazon EC2 Auto
Scaling in the Amazon EC2 Auto Scaling User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ActivityIds"`: The activity IDs of the desired scaling activities. If you omit this
property, all activities for the past six weeks are described. If unknown activities are
requested, they are ignored with no error. If you specify an Auto Scaling group, the
results are limited to that group. Array Members: Maximum number of 50 IDs.
- `"AutoScalingGroupName"`: The name of the Auto Scaling group.
- `"IncludeDeletedGroups"`: Indicates whether to include scaling activity from deleted Auto
Scaling groups.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 100 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_scaling_activities(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeScalingActivities"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_scaling_activities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeScalingActivities",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_process_types()
describe_scaling_process_types(params::Dict{String,<:Any})
Describes the scaling process types for use with the ResumeProcesses and SuspendProcesses
APIs.
"""
function describe_scaling_process_types(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeScalingProcessTypes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scaling_process_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeScalingProcessTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scheduled_actions()
describe_scheduled_actions(params::Dict{String,<:Any})
Gets information about the scheduled actions that haven't run or that have not reached
their end time. To describe the scaling activities for scheduled actions that have already
run, call the DescribeScalingActivities API.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupName"`: The name of the Auto Scaling group.
- `"EndTime"`: The latest scheduled start time to return. If scheduled action names are
provided, this property is ignored.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"ScheduledActionNames"`: The names of one or more scheduled actions. If you omit this
property, all scheduled actions are described. If you specify an unknown scheduled action,
it is ignored with no error. Array Members: Maximum number of 50 actions.
- `"StartTime"`: The earliest scheduled start time to return. If scheduled action names are
provided, this property is ignored.
"""
function describe_scheduled_actions(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeScheduledActions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_scheduled_actions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeScheduledActions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_tags()
describe_tags(params::Dict{String,<:Any})
Describes the specified tags. You can use filters to limit the results. For example, you
can query for the tags for a specific Auto Scaling group. You can specify multiple values
for a filter. A tag must match at least one of the specified values for it to be included
in the results. You can also specify multiple filters. The result includes information for
a particular tag only if it matches all the filters. If there's no match, no special
message is returned. For more information, see Tag Auto Scaling groups and instances in the
Amazon EC2 Auto Scaling User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: One or more filters to scope the tags to return. The maximum number of
filters per filter type (for example, auto-scaling-group) is 1000.
- `"MaxRecords"`: The maximum number of items to return with this call. The default value
is 50 and the maximum value is 100.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_tags(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"DescribeTags"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_tags(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeTags", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_termination_policy_types()
describe_termination_policy_types(params::Dict{String,<:Any})
Describes the termination policies supported by Amazon EC2 Auto Scaling. For more
information, see Configure termination policies for Amazon EC2 Auto Scaling in the Amazon
EC2 Auto Scaling User Guide.
"""
function describe_termination_policy_types(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeTerminationPolicyTypes";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_termination_policy_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeTerminationPolicyTypes",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_traffic_sources(auto_scaling_group_name)
describe_traffic_sources(auto_scaling_group_name, params::Dict{String,<:Any})
Gets information about the traffic sources for the specified Auto Scaling group. You can
optionally provide a traffic source type. If you provide a traffic source type, then the
results only include that traffic source type. If you do not provide a traffic source type,
then the results include all the traffic sources for the specified Auto Scaling group.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxRecords"`: The maximum number of items to return with this call. The maximum value
is 50.
- `"NextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"TrafficSourceType"`: The traffic source type that you want to describe. The following
lists the valid values: elb if the traffic source is a Classic Load Balancer. elbv2
if the traffic source is a Application Load Balancer, Gateway Load Balancer, or Network
Load Balancer. vpc-lattice if the traffic source is VPC Lattice.
"""
function describe_traffic_sources(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeTrafficSources",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_traffic_sources(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeTrafficSources",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_warm_pool(auto_scaling_group_name)
describe_warm_pool(auto_scaling_group_name, params::Dict{String,<:Any})
Gets information about a warm pool and its instances. For more information, see Warm pools
for Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxRecords"`: The maximum number of instances to return with this call. The maximum
value is 50.
- `"NextToken"`: The token for the next set of instances to return. (You received this
token from a previous call.)
"""
function describe_warm_pool(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DescribeWarmPool",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_warm_pool(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DescribeWarmPool",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_instances(auto_scaling_group_name, should_decrement_desired_capacity)
detach_instances(auto_scaling_group_name, should_decrement_desired_capacity, params::Dict{String,<:Any})
Removes one or more instances from the specified Auto Scaling group. After the instances
are detached, you can manage them independent of the Auto Scaling group. If you do not
specify the option to decrement the desired capacity, Amazon EC2 Auto Scaling launches
instances to replace the ones that are detached. If there is a Classic Load Balancer
attached to the Auto Scaling group, the instances are deregistered from the load balancer.
If there are target groups attached to the Auto Scaling group, the instances are
deregistered from the target groups. For more information, see Detach or attach instances
in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `should_decrement_desired_capacity`: Indicates whether the Auto Scaling group decrements
the desired capacity value by the number of instances detached.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceIds"`: The IDs of the instances. You can specify up to 20 instances.
"""
function detach_instances(
AutoScalingGroupName,
ShouldDecrementDesiredCapacity;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachInstances",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_instances(
AutoScalingGroupName,
ShouldDecrementDesiredCapacity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_load_balancer_target_groups(auto_scaling_group_name, target_group_arns)
detach_load_balancer_target_groups(auto_scaling_group_name, target_group_arns, params::Dict{String,<:Any})
This API operation is superseded by DetachTrafficSources, which can detach multiple
traffic sources types. We recommend using DetachTrafficSources to simplify how you manage
traffic sources. However, we continue to support DetachLoadBalancerTargetGroups. You can
use both the original DetachLoadBalancerTargetGroups API operation and DetachTrafficSources
on the same Auto Scaling group. Detaches one or more target groups from the specified Auto
Scaling group. When you detach a target group, it enters the Removing state while
deregistering the instances in the group. When all instances are deregistered, then you can
no longer describe the target group using the DescribeLoadBalancerTargetGroups API call.
The instances remain running. You can use this operation to detach target groups that were
attached by using AttachLoadBalancerTargetGroups, but not for target groups that were
attached by using AttachTrafficSources.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `target_group_arns`: The Amazon Resource Names (ARN) of the target groups. You can
specify up to 10 target groups.
"""
function detach_load_balancer_target_groups(
AutoScalingGroupName, TargetGroupARNs; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DetachLoadBalancerTargetGroups",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TargetGroupARNs" => TargetGroupARNs,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_load_balancer_target_groups(
AutoScalingGroupName,
TargetGroupARNs,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachLoadBalancerTargetGroups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TargetGroupARNs" => TargetGroupARNs,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_load_balancers(auto_scaling_group_name, load_balancer_names)
detach_load_balancers(auto_scaling_group_name, load_balancer_names, params::Dict{String,<:Any})
This API operation is superseded by DetachTrafficSources, which can detach multiple
traffic sources types. We recommend using DetachTrafficSources to simplify how you manage
traffic sources. However, we continue to support DetachLoadBalancers. You can use both the
original DetachLoadBalancers API operation and DetachTrafficSources on the same Auto
Scaling group. Detaches one or more Classic Load Balancers from the specified Auto Scaling
group. This operation detaches only Classic Load Balancers. If you have Application Load
Balancers, Network Load Balancers, or Gateway Load Balancers, use the
DetachLoadBalancerTargetGroups API instead. When you detach a load balancer, it enters the
Removing state while deregistering the instances in the group. When all instances are
deregistered, then you can no longer describe the load balancer using the
DescribeLoadBalancers API call. The instances remain running.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `load_balancer_names`: The names of the load balancers. You can specify up to 10 load
balancers.
"""
function detach_load_balancers(
AutoScalingGroupName,
LoadBalancerNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachLoadBalancers",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LoadBalancerNames" => LoadBalancerNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_load_balancers(
AutoScalingGroupName,
LoadBalancerNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachLoadBalancers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LoadBalancerNames" => LoadBalancerNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_traffic_sources(auto_scaling_group_name, traffic_sources)
detach_traffic_sources(auto_scaling_group_name, traffic_sources, params::Dict{String,<:Any})
Detaches one or more traffic sources from the specified Auto Scaling group. When you detach
a traffic source, it enters the Removing state while deregistering the instances in the
group. When all instances are deregistered, then you can no longer describe the traffic
source using the DescribeTrafficSources API call. The instances continue to run.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `traffic_sources`: The unique identifiers of one or more traffic sources. You can specify
up to 10 traffic sources.
"""
function detach_traffic_sources(
AutoScalingGroupName, TrafficSources; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DetachTrafficSources",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TrafficSources" => TrafficSources,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_traffic_sources(
AutoScalingGroupName,
TrafficSources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DetachTrafficSources",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"TrafficSources" => TrafficSources,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_metrics_collection(auto_scaling_group_name)
disable_metrics_collection(auto_scaling_group_name, params::Dict{String,<:Any})
Disables group metrics collection for the specified Auto Scaling group.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metrics"`: Identifies the metrics to disable. You can specify one or more of the
following metrics: GroupMinSize GroupMaxSize GroupDesiredCapacity
GroupInServiceInstances GroupPendingInstances GroupStandbyInstances
GroupTerminatingInstances GroupTotalInstances GroupInServiceCapacity
GroupPendingCapacity GroupStandbyCapacity GroupTerminatingCapacity
GroupTotalCapacity WarmPoolDesiredCapacity WarmPoolWarmedCapacity
WarmPoolPendingCapacity WarmPoolTerminatingCapacity WarmPoolTotalCapacity
GroupAndWarmPoolDesiredCapacity GroupAndWarmPoolTotalCapacity If you omit this
property, all metrics are disabled. For more information, see Amazon CloudWatch metrics for
Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User Guide.
"""
function disable_metrics_collection(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"DisableMetricsCollection",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_metrics_collection(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"DisableMetricsCollection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_metrics_collection(auto_scaling_group_name, granularity)
enable_metrics_collection(auto_scaling_group_name, granularity, params::Dict{String,<:Any})
Enables group metrics collection for the specified Auto Scaling group. You can use these
metrics to track changes in an Auto Scaling group and to set alarms on threshold values.
You can view group metrics using the Amazon EC2 Auto Scaling console or the CloudWatch
console. For more information, see Monitor CloudWatch metrics for your Auto Scaling groups
and instances in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `granularity`: The frequency at which Amazon EC2 Auto Scaling sends aggregated data to
CloudWatch. The only valid value is 1Minute.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metrics"`: Identifies the metrics to enable. You can specify one or more of the
following metrics: GroupMinSize GroupMaxSize GroupDesiredCapacity
GroupInServiceInstances GroupPendingInstances GroupStandbyInstances
GroupTerminatingInstances GroupTotalInstances GroupInServiceCapacity
GroupPendingCapacity GroupStandbyCapacity GroupTerminatingCapacity
GroupTotalCapacity WarmPoolDesiredCapacity WarmPoolWarmedCapacity
WarmPoolPendingCapacity WarmPoolTerminatingCapacity WarmPoolTotalCapacity
GroupAndWarmPoolDesiredCapacity GroupAndWarmPoolTotalCapacity If you specify
Granularity and don't specify any metrics, all metrics are enabled. For more information,
see Amazon CloudWatch metrics for Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling
User Guide.
"""
function enable_metrics_collection(
AutoScalingGroupName, Granularity; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"EnableMetricsCollection",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName, "Granularity" => Granularity
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_metrics_collection(
AutoScalingGroupName,
Granularity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"EnableMetricsCollection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"Granularity" => Granularity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enter_standby(auto_scaling_group_name, should_decrement_desired_capacity)
enter_standby(auto_scaling_group_name, should_decrement_desired_capacity, params::Dict{String,<:Any})
Moves the specified instances into the standby state. If you choose to decrement the
desired capacity of the Auto Scaling group, the instances can enter standby as long as the
desired capacity of the Auto Scaling group after the instances are placed into standby is
equal to or greater than the minimum capacity of the group. If you choose not to decrement
the desired capacity of the Auto Scaling group, the Auto Scaling group launches new
instances to replace the instances on standby. For more information, see Temporarily
removing instances from your Auto Scaling group in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `should_decrement_desired_capacity`: Indicates whether to decrement the desired capacity
of the Auto Scaling group by the number of instances moved to Standby mode.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceIds"`: The IDs of the instances. You can specify up to 20 instances.
"""
function enter_standby(
AutoScalingGroupName,
ShouldDecrementDesiredCapacity;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"EnterStandby",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enter_standby(
AutoScalingGroupName,
ShouldDecrementDesiredCapacity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"EnterStandby",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
execute_policy(policy_name)
execute_policy(policy_name, params::Dict{String,<:Any})
Executes the specified policy. This can be useful for testing the design of your scaling
policy.
# Arguments
- `policy_name`: The name or ARN of the policy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoScalingGroupName"`: The name of the Auto Scaling group.
- `"BreachThreshold"`: The breach threshold for the alarm. Required if the policy type is
StepScaling and not supported otherwise.
- `"HonorCooldown"`: Indicates whether Amazon EC2 Auto Scaling waits for the cooldown
period to complete before executing the policy. Valid only if the policy type is
SimpleScaling. For more information, see Scaling cooldowns for Amazon EC2 Auto Scaling in
the Amazon EC2 Auto Scaling User Guide.
- `"MetricValue"`: The metric value to compare to BreachThreshold. This enables you to
execute a policy of type StepScaling and determine which step adjustment to use. For
example, if the breach threshold is 50 and you want to use a step adjustment with a lower
bound of 0 and an upper bound of 10, you can set the metric value to 59. If you specify a
metric value that doesn't correspond to a step adjustment for the policy, the call returns
an error. Required if the policy type is StepScaling and not supported otherwise.
"""
function execute_policy(PolicyName; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling(
"ExecutePolicy",
Dict{String,Any}("PolicyName" => PolicyName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function execute_policy(
PolicyName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"ExecutePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PolicyName" => PolicyName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
exit_standby(auto_scaling_group_name)
exit_standby(auto_scaling_group_name, params::Dict{String,<:Any})
Moves the specified instances out of the standby state. After you put the instances back in
service, the desired capacity is incremented. For more information, see Temporarily
removing instances from your Auto Scaling group in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceIds"`: The IDs of the instances. You can specify up to 20 instances.
"""
function exit_standby(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"ExitStandby",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function exit_standby(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"ExitStandby",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_predictive_scaling_forecast(auto_scaling_group_name, end_time, policy_name, start_time)
get_predictive_scaling_forecast(auto_scaling_group_name, end_time, policy_name, start_time, params::Dict{String,<:Any})
Retrieves the forecast data for a predictive scaling policy. Load forecasts are predictions
of the hourly load values using historical load data from CloudWatch and an analysis of
historical trends. Capacity forecasts are represented as predicted values for the minimum
capacity that is needed on an hourly basis, based on the hourly load forecast. A minimum of
24 hours of data is required to create the initial forecasts. However, having a full 14
days of historical data results in more accurate forecasts. For more information, see
Predictive scaling for Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `end_time`: The exclusive end time of the time range for the forecast data to get. The
maximum time duration between the start and end time is 30 days. Although this parameter
can accept a date and time that is more than two days in the future, the availability of
forecast data has limits. Amazon EC2 Auto Scaling only issues forecasts for periods of two
days in advance.
- `policy_name`: The name of the policy.
- `start_time`: The inclusive start time of the time range for the forecast data to get. At
most, the date and time can be one year before the current date and time.
"""
function get_predictive_scaling_forecast(
AutoScalingGroupName,
EndTime,
PolicyName,
StartTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"GetPredictiveScalingForecast",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"EndTime" => EndTime,
"PolicyName" => PolicyName,
"StartTime" => StartTime,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_predictive_scaling_forecast(
AutoScalingGroupName,
EndTime,
PolicyName,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"GetPredictiveScalingForecast",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"EndTime" => EndTime,
"PolicyName" => PolicyName,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_lifecycle_hook(auto_scaling_group_name, lifecycle_hook_name)
put_lifecycle_hook(auto_scaling_group_name, lifecycle_hook_name, params::Dict{String,<:Any})
Creates or updates a lifecycle hook for the specified Auto Scaling group. Lifecycle hooks
let you create solutions that are aware of events in the Auto Scaling instance lifecycle,
and then perform a custom action on instances when the corresponding lifecycle event
occurs. This step is a part of the procedure for adding a lifecycle hook to an Auto Scaling
group: (Optional) Create a launch template or launch configuration with a user data
script that runs while an instance is in a wait state due to a lifecycle hook. (Optional)
Create a Lambda function and a rule that allows Amazon EventBridge to invoke your Lambda
function when an instance is put into a wait state due to a lifecycle hook. (Optional)
Create a notification target and an IAM role. The target can be either an Amazon SQS queue
or an Amazon SNS topic. The role allows Amazon EC2 Auto Scaling to publish lifecycle
notifications to the target. Create the lifecycle hook. Specify whether the hook is used
when the instances launch or terminate. If you need more time, record the lifecycle
action heartbeat to keep the instance in a wait state using the
RecordLifecycleActionHeartbeat API call. If you finish before the timeout period ends,
send a callback by using the CompleteLifecycleAction API call. For more information, see
Amazon EC2 Auto Scaling lifecycle hooks in the Amazon EC2 Auto Scaling User Guide. If you
exceed your maximum limit of lifecycle hooks, which by default is 50 per Auto Scaling
group, the call fails. You can view the lifecycle hooks for an Auto Scaling group using the
DescribeLifecycleHooks API call. If you are no longer using a lifecycle hook, you can
delete it by calling the DeleteLifecycleHook API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `lifecycle_hook_name`: The name of the lifecycle hook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DefaultResult"`: The action the Auto Scaling group takes when the lifecycle hook
timeout elapses or if an unexpected failure occurs. The default value is ABANDON. Valid
values: CONTINUE | ABANDON
- `"HeartbeatTimeout"`: The maximum time, in seconds, that can elapse before the lifecycle
hook times out. The range is from 30 to 7200 seconds. The default value is 3600 seconds (1
hour).
- `"LifecycleTransition"`: The lifecycle transition. For Auto Scaling groups, there are two
major lifecycle transitions. To create a lifecycle hook for scale-out events, specify
autoscaling:EC2_INSTANCE_LAUNCHING. To create a lifecycle hook for scale-in events,
specify autoscaling:EC2_INSTANCE_TERMINATING. Required for new lifecycle hooks, but
optional when updating existing hooks.
- `"NotificationMetadata"`: Additional information that you want to include any time Amazon
EC2 Auto Scaling sends a message to the notification target.
- `"NotificationTargetARN"`: The Amazon Resource Name (ARN) of the notification target that
Amazon EC2 Auto Scaling uses to notify you when an instance is in a wait state for the
lifecycle hook. You can specify either an Amazon SNS topic or an Amazon SQS queue. If you
specify an empty string, this overrides the current ARN. This operation uses the JSON
format when sending notifications to an Amazon SQS queue, and an email key-value pair
format when sending notifications to an Amazon SNS topic. When you specify a notification
target, Amazon EC2 Auto Scaling sends it a test message. Test messages contain the
following additional key-value pair: \"Event\": \"autoscaling:TEST_NOTIFICATION\".
- `"RoleARN"`: The ARN of the IAM role that allows the Auto Scaling group to publish to the
specified notification target. Valid only if the notification target is an Amazon SNS topic
or an Amazon SQS queue. Required for new lifecycle hooks, but optional when updating
existing hooks.
"""
function put_lifecycle_hook(
AutoScalingGroupName,
LifecycleHookName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutLifecycleHook",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_lifecycle_hook(
AutoScalingGroupName,
LifecycleHookName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutLifecycleHook",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn)
put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn, params::Dict{String,<:Any})
Configures an Auto Scaling group to send notifications when specified events take place.
Subscribers to the specified topic can have messages delivered to an endpoint such as a web
server or an email address. This configuration overwrites any existing configuration. For
more information, see Amazon SNS notification options for Amazon EC2 Auto Scaling in the
Amazon EC2 Auto Scaling User Guide. If you exceed your maximum limit of SNS topics, which
is 10 per Auto Scaling group, the call fails.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `notification_types`: The type of event that causes the notification to be sent. To query
the notification types supported by Amazon EC2 Auto Scaling, call the
DescribeAutoScalingNotificationTypes API.
- `topic_arn`: The Amazon Resource Name (ARN) of the Amazon SNS topic.
"""
function put_notification_configuration(
AutoScalingGroupName,
NotificationTypes,
TopicARN;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutNotificationConfiguration",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"NotificationTypes" => NotificationTypes,
"TopicARN" => TopicARN,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_notification_configuration(
AutoScalingGroupName,
NotificationTypes,
TopicARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutNotificationConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"NotificationTypes" => NotificationTypes,
"TopicARN" => TopicARN,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_scaling_policy(auto_scaling_group_name, policy_name)
put_scaling_policy(auto_scaling_group_name, policy_name, params::Dict{String,<:Any})
Creates or updates a scaling policy for an Auto Scaling group. Scaling policies are used to
scale an Auto Scaling group based on configurable metrics. If no policies are defined, the
dynamic scaling and predictive scaling features are not used. For more information about
using dynamic scaling, see Target tracking scaling policies and Step and simple scaling
policies in the Amazon EC2 Auto Scaling User Guide. For more information about using
predictive scaling, see Predictive scaling for Amazon EC2 Auto Scaling in the Amazon EC2
Auto Scaling User Guide. You can view the scaling policies for an Auto Scaling group using
the DescribePolicies API call. If you are no longer using a scaling policy, you can delete
it by calling the DeletePolicy API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `policy_name`: The name of the policy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdjustmentType"`: Specifies how the scaling adjustment is interpreted (for example, an
absolute number or a percentage). The valid values are ChangeInCapacity, ExactCapacity, and
PercentChangeInCapacity. Required if the policy type is StepScaling or SimpleScaling. For
more information, see Scaling adjustment types in the Amazon EC2 Auto Scaling User Guide.
- `"Cooldown"`: A cooldown period, in seconds, that applies to a specific simple scaling
policy. When a cooldown period is specified here, it overrides the default cooldown. Valid
only if the policy type is SimpleScaling. For more information, see Scaling cooldowns for
Amazon EC2 Auto Scaling in the Amazon EC2 Auto Scaling User Guide. Default: None
- `"Enabled"`: Indicates whether the scaling policy is enabled or disabled. The default is
enabled. For more information, see Disable a scaling policy for an Auto Scaling group in
the Amazon EC2 Auto Scaling User Guide.
- `"EstimatedInstanceWarmup"`: Not needed if the default instance warmup is defined for
the group. The estimated time, in seconds, until a newly launched instance can contribute
to the CloudWatch metrics. This warm-up period applies to instances launched due to a
specific target tracking or step scaling policy. When a warm-up period is specified here,
it overrides the default instance warmup. Valid only if the policy type is
TargetTrackingScaling or StepScaling. The default is to use the value for the default
instance warmup defined for the group. If default instance warmup is null, then
EstimatedInstanceWarmup falls back to the value of default cooldown.
- `"MetricAggregationType"`: The aggregation type for the CloudWatch metrics. The valid
values are Minimum, Maximum, and Average. If the aggregation type is null, the value is
treated as Average. Valid only if the policy type is StepScaling.
- `"MinAdjustmentMagnitude"`: The minimum value to scale by when the adjustment type is
PercentChangeInCapacity. For example, suppose that you create a step scaling policy to
scale out an Auto Scaling group by 25 percent and you specify a MinAdjustmentMagnitude of
2. If the group has 4 instances and the scaling policy is performed, 25 percent of 4 is 1.
However, because you specified a MinAdjustmentMagnitude of 2, Amazon EC2 Auto Scaling
scales out the group by 2 instances. Valid only if the policy type is StepScaling or
SimpleScaling. For more information, see Scaling adjustment types in the Amazon EC2 Auto
Scaling User Guide. Some Auto Scaling groups use instance weights. In this case, set the
MinAdjustmentMagnitude to a value that is at least as large as your largest instance
weight.
- `"MinAdjustmentStep"`: Available for backward compatibility. Use MinAdjustmentMagnitude
instead.
- `"PolicyType"`: One of the following policy types: TargetTrackingScaling
StepScaling SimpleScaling (default) PredictiveScaling
- `"PredictiveScalingConfiguration"`: A predictive scaling policy. Provides support for
predefined and custom metrics. Predefined metrics include CPU utilization, network in/out,
and the Application Load Balancer request count. For more information, see
PredictiveScalingConfiguration in the Amazon EC2 Auto Scaling API Reference. Required if
the policy type is PredictiveScaling.
- `"ScalingAdjustment"`: The amount by which to scale, based on the specified adjustment
type. A positive value adds to the current capacity while a negative number removes from
the current capacity. For exact capacity, you must specify a non-negative value. Required
if the policy type is SimpleScaling. (Not used with any other policy type.)
- `"StepAdjustments"`: A set of adjustments that enable you to scale based on the size of
the alarm breach. Required if the policy type is StepScaling. (Not used with any other
policy type.)
- `"TargetTrackingConfiguration"`: A target tracking scaling policy. Provides support for
predefined or custom metrics. The following predefined metrics are available:
ASGAverageCPUUtilization ASGAverageNetworkIn ASGAverageNetworkOut
ALBRequestCountPerTarget If you specify ALBRequestCountPerTarget for the metric, you
must specify the ResourceLabel property with the PredefinedMetricSpecification. For more
information, see TargetTrackingConfiguration in the Amazon EC2 Auto Scaling API Reference.
Required if the policy type is TargetTrackingScaling.
"""
function put_scaling_policy(
AutoScalingGroupName, PolicyName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"PutScalingPolicy",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName, "PolicyName" => PolicyName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_scaling_policy(
AutoScalingGroupName,
PolicyName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutScalingPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"PolicyName" => PolicyName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_scheduled_update_group_action(auto_scaling_group_name, scheduled_action_name)
put_scheduled_update_group_action(auto_scaling_group_name, scheduled_action_name, params::Dict{String,<:Any})
Creates or updates a scheduled scaling action for an Auto Scaling group. For more
information, see Scheduled scaling in the Amazon EC2 Auto Scaling User Guide. You can view
the scheduled actions for an Auto Scaling group using the DescribeScheduledActions API
call. If you are no longer using a scheduled action, you can delete it by calling the
DeleteScheduledAction API. If you try to schedule your action in the past, Amazon EC2 Auto
Scaling returns an error message.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `scheduled_action_name`: The name of this scaling action.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DesiredCapacity"`: The desired capacity is the initial capacity of the Auto Scaling
group after the scheduled action runs and the capacity it attempts to maintain. It can
scale beyond this capacity if you add more scaling conditions. You must specify at least
one of the following properties: MaxSize, MinSize, or DesiredCapacity.
- `"EndTime"`: The date and time for the recurring schedule to end, in UTC. For example,
\"2021-06-01T00:00:00Z\".
- `"MaxSize"`: The maximum size of the Auto Scaling group.
- `"MinSize"`: The minimum size of the Auto Scaling group.
- `"Recurrence"`: The recurring schedule for this action. This format consists of five
fields separated by white spaces: [Minute] [Hour] [Day_of_Month] [Month_of_Year]
[Day_of_Week]. The value must be in quotes (for example, \"30 0 1 1,6,12 *\"). For more
information about this format, see Crontab. When StartTime and EndTime are specified with
Recurrence, they form the boundaries of when the recurring action starts and stops. Cron
expressions use Universal Coordinated Time (UTC) by default.
- `"StartTime"`: The date and time for this action to start, in YYYY-MM-DDThh:mm:ssZ format
in UTC/GMT only and in quotes (for example, \"2021-06-01T00:00:00Z\"). If you specify
Recurrence and StartTime, Amazon EC2 Auto Scaling performs the action at this time, and
then performs the action based on the specified recurrence.
- `"Time"`: This property is no longer used.
- `"TimeZone"`: Specifies the time zone for a cron expression. If a time zone is not
provided, UTC is used by default. Valid values are the canonical names of the IANA time
zones, derived from the IANA Time Zone Database (such as Etc/GMT+9 or Pacific/Tahiti). For
more information, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones.
"""
function put_scheduled_update_group_action(
AutoScalingGroupName,
ScheduledActionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutScheduledUpdateGroupAction",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionName" => ScheduledActionName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_scheduled_update_group_action(
AutoScalingGroupName,
ScheduledActionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutScheduledUpdateGroupAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"ScheduledActionName" => ScheduledActionName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_warm_pool(auto_scaling_group_name)
put_warm_pool(auto_scaling_group_name, params::Dict{String,<:Any})
Creates or updates a warm pool for the specified Auto Scaling group. A warm pool is a pool
of pre-initialized EC2 instances that sits alongside the Auto Scaling group. Whenever your
application needs to scale out, the Auto Scaling group can draw on the warm pool to meet
its new desired capacity. This operation must be called from the Region in which the Auto
Scaling group was created. You can view the instances in the warm pool using the
DescribeWarmPool API call. If you are no longer using a warm pool, you can delete it by
calling the DeleteWarmPool API. For more information, see Warm pools for Amazon EC2 Auto
Scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceReusePolicy"`: Indicates whether instances in the Auto Scaling group can be
returned to the warm pool on scale in. The default is to terminate instances in the Auto
Scaling group when the group scales in.
- `"MaxGroupPreparedCapacity"`: Specifies the maximum number of instances that are allowed
to be in the warm pool or in any state except Terminated for the Auto Scaling group. This
is an optional property. Specify it only if you do not want the warm pool size to be
determined by the difference between the group's maximum capacity and its desired capacity.
If a value for MaxGroupPreparedCapacity is not specified, Amazon EC2 Auto Scaling
launches and maintains the difference between the group's maximum capacity and its desired
capacity. If you specify a value for MaxGroupPreparedCapacity, Amazon EC2 Auto Scaling uses
the difference between the MaxGroupPreparedCapacity and the desired capacity instead. The
size of the warm pool is dynamic. Only when MaxGroupPreparedCapacity and MinSize are set to
the same value does the warm pool have an absolute size. If the desired capacity of the
Auto Scaling group is higher than the MaxGroupPreparedCapacity, the capacity of the warm
pool is 0, unless you specify a value for MinSize. To remove a value that you previously
set, include the property but specify -1 for the value.
- `"MinSize"`: Specifies the minimum number of instances to maintain in the warm pool. This
helps you to ensure that there is always a certain number of warmed instances available to
handle traffic spikes. Defaults to 0 if not specified.
- `"PoolState"`: Sets the instance state to transition to after the lifecycle actions are
complete. Default is Stopped.
"""
function put_warm_pool(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"PutWarmPool",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_warm_pool(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"PutWarmPool",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
record_lifecycle_action_heartbeat(auto_scaling_group_name, lifecycle_hook_name)
record_lifecycle_action_heartbeat(auto_scaling_group_name, lifecycle_hook_name, params::Dict{String,<:Any})
Records a heartbeat for the lifecycle action associated with the specified token or
instance. This extends the timeout by the length of time defined using the PutLifecycleHook
API call. This step is a part of the procedure for adding a lifecycle hook to an Auto
Scaling group: (Optional) Create a launch template or launch configuration with a user
data script that runs while an instance is in a wait state due to a lifecycle hook.
(Optional) Create a Lambda function and a rule that allows Amazon EventBridge to invoke
your Lambda function when an instance is put into a wait state due to a lifecycle hook.
(Optional) Create a notification target and an IAM role. The target can be either an Amazon
SQS queue or an Amazon SNS topic. The role allows Amazon EC2 Auto Scaling to publish
lifecycle notifications to the target. Create the lifecycle hook. Specify whether the
hook is used when the instances launch or terminate. If you need more time, record the
lifecycle action heartbeat to keep the instance in a wait state. If you finish before
the timeout period ends, send a callback by using the CompleteLifecycleAction API call.
For more information, see Amazon EC2 Auto Scaling lifecycle hooks in the Amazon EC2 Auto
Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `lifecycle_hook_name`: The name of the lifecycle hook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceId"`: The ID of the instance.
- `"LifecycleActionToken"`: A token that uniquely identifies a specific lifecycle action
associated with an instance. Amazon EC2 Auto Scaling sends this token to the notification
target that you specified when you created the lifecycle hook.
"""
function record_lifecycle_action_heartbeat(
AutoScalingGroupName,
LifecycleHookName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"RecordLifecycleActionHeartbeat",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function record_lifecycle_action_heartbeat(
AutoScalingGroupName,
LifecycleHookName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"RecordLifecycleActionHeartbeat",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"LifecycleHookName" => LifecycleHookName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
resume_processes(auto_scaling_group_name)
resume_processes(auto_scaling_group_name, params::Dict{String,<:Any})
Resumes the specified suspended auto scaling processes, or all suspended process, for the
specified Auto Scaling group. For more information, see Suspend and resume Amazon EC2 Auto
Scaling processes in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ScalingProcesses"`: One or more of the following processes: Launch Terminate
AddToLoadBalancer AlarmNotification AZRebalance HealthCheck InstanceRefresh
ReplaceUnhealthy ScheduledActions If you omit this property, all processes are
specified.
"""
function resume_processes(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"ResumeProcesses",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function resume_processes(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"ResumeProcesses",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
rollback_instance_refresh(auto_scaling_group_name)
rollback_instance_refresh(auto_scaling_group_name, params::Dict{String,<:Any})
Cancels an instance refresh that is in progress and rolls back any changes that it made.
Amazon EC2 Auto Scaling replaces any instances that were replaced during the instance
refresh. This restores your Auto Scaling group to the configuration that it was using
before the start of the instance refresh. This operation is part of the instance refresh
feature in Amazon EC2 Auto Scaling, which helps you update instances in your Auto Scaling
group after you make configuration changes. A rollback is not supported in the following
situations: There is no desired configuration specified for the instance refresh. The
Auto Scaling group has a launch template that uses an Amazon Web Services Systems Manager
parameter instead of an AMI ID for the ImageId property. The Auto Scaling group uses the
launch template's Latest or Default version. When you receive a successful response from
this operation, Amazon EC2 Auto Scaling immediately begins replacing instances. You can
check the status of this operation through the DescribeInstanceRefreshes API operation.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
"""
function rollback_instance_refresh(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"RollbackInstanceRefresh",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function rollback_instance_refresh(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"RollbackInstanceRefresh",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_desired_capacity(auto_scaling_group_name, desired_capacity)
set_desired_capacity(auto_scaling_group_name, desired_capacity, params::Dict{String,<:Any})
Sets the size of the specified Auto Scaling group. If a scale-in activity occurs as a
result of a new DesiredCapacity value that is lower than the current size of the group, the
Auto Scaling group uses its termination policy to determine which instances to terminate.
For more information, see Manual scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `desired_capacity`: The desired capacity is the initial capacity of the Auto Scaling
group after this operation completes and the capacity it attempts to maintain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"HonorCooldown"`: Indicates whether Amazon EC2 Auto Scaling waits for the cooldown
period to complete before initiating a scaling activity to set your Auto Scaling group to
its new capacity. By default, Amazon EC2 Auto Scaling does not honor the cooldown period
during manual scaling activities.
"""
function set_desired_capacity(
AutoScalingGroupName, DesiredCapacity; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"SetDesiredCapacity",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"DesiredCapacity" => DesiredCapacity,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_desired_capacity(
AutoScalingGroupName,
DesiredCapacity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"SetDesiredCapacity",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"DesiredCapacity" => DesiredCapacity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_instance_health(health_status, instance_id)
set_instance_health(health_status, instance_id, params::Dict{String,<:Any})
Sets the health status of the specified instance. For more information, see Health checks
for instances in an Auto Scaling group in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `health_status`: The health status of the instance. Set to Healthy to have the instance
remain in service. Set to Unhealthy to have the instance be out of service. Amazon EC2 Auto
Scaling terminates and replaces the unhealthy instance.
- `instance_id`: The ID of the instance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ShouldRespectGracePeriod"`: If the Auto Scaling group of the specified instance has a
HealthCheckGracePeriod specified for the group, by default, this call respects the grace
period. Set this to False, to have the call not respect the grace period associated with
the group. For more information about the health check grace period, see Set the health
check grace period for an Auto Scaling group in the Amazon EC2 Auto Scaling User Guide.
"""
function set_instance_health(
HealthStatus, InstanceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"SetInstanceHealth",
Dict{String,Any}("HealthStatus" => HealthStatus, "InstanceId" => InstanceId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_instance_health(
HealthStatus,
InstanceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"SetInstanceHealth",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"HealthStatus" => HealthStatus, "InstanceId" => InstanceId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_instance_protection(auto_scaling_group_name, instance_ids, protected_from_scale_in)
set_instance_protection(auto_scaling_group_name, instance_ids, protected_from_scale_in, params::Dict{String,<:Any})
Updates the instance protection settings of the specified instances. This operation cannot
be called on instances in a warm pool. For more information, see Use instance scale-in
protection in the Amazon EC2 Auto Scaling User Guide. If you exceed your maximum limit of
instance IDs, which is 50 per Auto Scaling group, the call fails.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
- `instance_ids`: One or more instance IDs. You can specify up to 50 instances.
- `protected_from_scale_in`: Indicates whether the instance is protected from termination
by Amazon EC2 Auto Scaling when scaling in.
"""
function set_instance_protection(
AutoScalingGroupName,
InstanceIds,
ProtectedFromScaleIn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"SetInstanceProtection",
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"InstanceIds" => InstanceIds,
"ProtectedFromScaleIn" => ProtectedFromScaleIn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_instance_protection(
AutoScalingGroupName,
InstanceIds,
ProtectedFromScaleIn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"SetInstanceProtection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AutoScalingGroupName" => AutoScalingGroupName,
"InstanceIds" => InstanceIds,
"ProtectedFromScaleIn" => ProtectedFromScaleIn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_instance_refresh(auto_scaling_group_name)
start_instance_refresh(auto_scaling_group_name, params::Dict{String,<:Any})
Starts an instance refresh. This operation is part of the instance refresh feature in
Amazon EC2 Auto Scaling, which helps you update instances in your Auto Scaling group. This
feature is helpful, for example, when you have a new AMI or a new user data script. You
just need to create a new launch template that specifies the new AMI or user data script.
Then start an instance refresh to immediately begin the process of updating instances in
the group. If successful, the request's response contains a unique ID that you can use to
track the progress of the instance refresh. To query its status, call the
DescribeInstanceRefreshes API. To describe the instance refreshes that have already run,
call the DescribeInstanceRefreshes API. To cancel an instance refresh that is in progress,
use the CancelInstanceRefresh API. An instance refresh might fail for several reasons,
such as EC2 launch failures, misconfigured health checks, or not ignoring or allowing the
termination of instances that are in Standby state or protected from scale in. You can
monitor for failed EC2 launches using the scaling activities. To find the scaling
activities, call the DescribeScalingActivities API. If you enable auto rollback, your Auto
Scaling group will be rolled back automatically when the instance refresh fails. You can
enable this feature before starting an instance refresh by specifying the AutoRollback
property in the instance refresh preferences. Otherwise, to roll back an instance refresh
before it finishes, use the RollbackInstanceRefresh API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DesiredConfiguration"`: The desired configuration. For example, the desired
configuration can specify a new launch template or a new version of the current launch
template. Once the instance refresh succeeds, Amazon EC2 Auto Scaling updates the settings
of the Auto Scaling group to reflect the new desired configuration. When you specify a
new launch template or a new version of the current launch template for your desired
configuration, consider enabling the SkipMatching property in preferences. If it's enabled,
Amazon EC2 Auto Scaling skips replacing instances that already use the specified launch
template and instance types. This can help you reduce the number of replacements that are
required to apply updates.
- `"Preferences"`: Sets your preferences for the instance refresh so that it performs as
expected when you start it. Includes the instance warmup time, the minimum and maximum
healthy percentages, and the behaviors that you want Amazon EC2 Auto Scaling to use if
instances that are in Standby state or protected from scale in are found. You can also
choose to enable additional features, such as the following: Auto rollback Checkpoints
CloudWatch alarms Skip matching
- `"Strategy"`: The strategy to use for the instance refresh. The only valid value is
Rolling.
"""
function start_instance_refresh(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"StartInstanceRefresh",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_instance_refresh(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"StartInstanceRefresh",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
suspend_processes(auto_scaling_group_name)
suspend_processes(auto_scaling_group_name, params::Dict{String,<:Any})
Suspends the specified auto scaling processes, or all processes, for the specified Auto
Scaling group. If you suspend either the Launch or Terminate process types, it can prevent
other process types from functioning properly. For more information, see Suspend and resume
Amazon EC2 Auto Scaling processes in the Amazon EC2 Auto Scaling User Guide. To resume
processes that have been suspended, call the ResumeProcesses API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ScalingProcesses"`: One or more of the following processes: Launch Terminate
AddToLoadBalancer AlarmNotification AZRebalance HealthCheck InstanceRefresh
ReplaceUnhealthy ScheduledActions If you omit this property, all processes are
specified.
"""
function suspend_processes(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"SuspendProcesses",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function suspend_processes(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"SuspendProcesses",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity, params::Dict{String,<:Any})
Terminates the specified instance and optionally adjusts the desired group size. This
operation cannot be called on instances in a warm pool. This call simply makes a
termination request. The instance is not terminated immediately. When an instance is
terminated, the instance status changes to terminated. You can't connect to or start an
instance after you've terminated it. If you do not specify the option to decrement the
desired capacity, Amazon EC2 Auto Scaling launches instances to replace the ones that are
terminated. By default, Amazon EC2 Auto Scaling balances instances across all Availability
Zones. If you decrement the desired capacity, your Auto Scaling group can become unbalanced
between Availability Zones. Amazon EC2 Auto Scaling tries to rebalance the group, and
rebalancing might terminate instances in other zones. For more information, see Manual
scaling in the Amazon EC2 Auto Scaling User Guide.
# Arguments
- `instance_id`: The ID of the instance.
- `should_decrement_desired_capacity`: Indicates whether terminating the instance also
decrements the size of the Auto Scaling group.
"""
function terminate_instance_in_auto_scaling_group(
InstanceId,
ShouldDecrementDesiredCapacity;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"TerminateInstanceInAutoScalingGroup",
Dict{String,Any}(
"InstanceId" => InstanceId,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function terminate_instance_in_auto_scaling_group(
InstanceId,
ShouldDecrementDesiredCapacity,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"TerminateInstanceInAutoScalingGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"InstanceId" => InstanceId,
"ShouldDecrementDesiredCapacity" => ShouldDecrementDesiredCapacity,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_auto_scaling_group(auto_scaling_group_name)
update_auto_scaling_group(auto_scaling_group_name, params::Dict{String,<:Any})
We strongly recommend that all Auto Scaling groups use launch templates to ensure full
functionality for Amazon EC2 Auto Scaling and Amazon EC2. Updates the configuration for
the specified Auto Scaling group. To update an Auto Scaling group, specify the name of the
group and the property that you want to change. Any properties that you don't specify are
not changed by this update request. The new settings take effect on any scaling activities
after this call returns. If you associate a new launch configuration or template with an
Auto Scaling group, all new instances will get the updated configuration. Existing
instances continue to run with the configuration that they were originally launched with.
When you update a group to specify a mixed instances policy instead of a launch
configuration or template, existing instances may be replaced to match the new purchasing
options that you specified in the policy. For example, if the group currently has 100%
On-Demand capacity and the policy specifies 50% Spot capacity, this means that half of your
instances will be gradually terminated and relaunched as Spot Instances. When replacing
instances, Amazon EC2 Auto Scaling launches new instances before terminating the old ones,
so that updating your group does not compromise the performance or availability of your
application. Note the following about changing DesiredCapacity, MaxSize, or MinSize: If a
scale-in activity occurs as a result of a new DesiredCapacity value that is lower than the
current size of the group, the Auto Scaling group uses its termination policy to determine
which instances to terminate. If you specify a new value for MinSize without specifying a
value for DesiredCapacity, and the new MinSize is larger than the current size of the
group, this sets the group's DesiredCapacity to the new MinSize value. If you specify a
new value for MaxSize without specifying a value for DesiredCapacity, and the new MaxSize
is smaller than the current size of the group, this sets the group's DesiredCapacity to the
new MaxSize value. To see which properties have been set, call the
DescribeAutoScalingGroups API. To view the scaling policies for an Auto Scaling group, call
the DescribePolicies API. If the group has scaling policies, you can update them by calling
the PutScalingPolicy API.
# Arguments
- `auto_scaling_group_name`: The name of the Auto Scaling group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AvailabilityZones"`: One or more Availability Zones for the group.
- `"CapacityRebalance"`: Enables or disables Capacity Rebalancing. For more information,
see Use Capacity Rebalancing to handle Amazon EC2 Spot Interruptions in the Amazon EC2 Auto
Scaling User Guide.
- `"Context"`: Reserved.
- `"DefaultCooldown"`: Only needed if you use simple scaling policies. The amount of
time, in seconds, between one scaling activity ending and another one starting due to
simple scaling policies. For more information, see Scaling cooldowns for Amazon EC2 Auto
Scaling in the Amazon EC2 Auto Scaling User Guide.
- `"DefaultInstanceWarmup"`: The amount of time, in seconds, until a new instance is
considered to have finished initializing and resource consumption to become stable after it
enters the InService state. During an instance refresh, Amazon EC2 Auto Scaling waits for
the warm-up period after it replaces an instance before it moves on to replacing the next
instance. Amazon EC2 Auto Scaling also waits for the warm-up period before aggregating the
metrics for new instances with existing instances in the Amazon CloudWatch metrics that are
used for scaling, resulting in more reliable usage data. For more information, see Set the
default instance warmup for an Auto Scaling group in the Amazon EC2 Auto Scaling User
Guide. To manage various warm-up settings at the group level, we recommend that you set
the default instance warmup, even if it is set to 0 seconds. To remove a value that you
previously set, include the property but specify -1 for the value. However, we strongly
recommend keeping the default instance warmup enabled by specifying a value of 0 or other
nominal value.
- `"DesiredCapacity"`: The desired capacity is the initial capacity of the Auto Scaling
group after this operation completes and the capacity it attempts to maintain. This number
must be greater than or equal to the minimum size of the group and less than or equal to
the maximum size of the group.
- `"DesiredCapacityType"`: The unit of measurement for the value specified for desired
capacity. Amazon EC2 Auto Scaling supports DesiredCapacityType for attribute-based instance
type selection only. For more information, see Create a mixed instances group using
attribute-based instance type selection in the Amazon EC2 Auto Scaling User Guide. By
default, Amazon EC2 Auto Scaling specifies units, which translates into number of
instances. Valid values: units | vcpu | memory-mib
- `"HealthCheckGracePeriod"`: The amount of time, in seconds, that Amazon EC2 Auto Scaling
waits before checking the health status of an EC2 instance that has come into service and
marking it unhealthy due to a failed health check. This is useful if your instances do not
immediately pass their health checks after they enter the InService state. For more
information, see Set the health check grace period for an Auto Scaling group in the Amazon
EC2 Auto Scaling User Guide.
- `"HealthCheckType"`: A comma-separated value string of one or more health check types.
The valid values are EC2, ELB, and VPC_LATTICE. EC2 is the default health check and cannot
be disabled. For more information, see Health checks for instances in an Auto Scaling group
in the Amazon EC2 Auto Scaling User Guide. Only specify EC2 if you must clear a value that
was previously set.
- `"InstanceMaintenancePolicy"`: An instance maintenance policy. For more information, see
Set instance maintenance policy in the Amazon EC2 Auto Scaling User Guide.
- `"LaunchConfigurationName"`: The name of the launch configuration. If you specify
LaunchConfigurationName in your update request, you can't specify LaunchTemplate or
MixedInstancesPolicy.
- `"LaunchTemplate"`: The launch template and version to use to specify the updates. If you
specify LaunchTemplate in your update request, you can't specify LaunchConfigurationName or
MixedInstancesPolicy.
- `"MaxInstanceLifetime"`: The maximum amount of time, in seconds, that an instance can be
in service. The default is null. If specified, the value must be either 0 or a number equal
to or greater than 86,400 seconds (1 day). To clear a previously set value, specify a new
value of 0. For more information, see Replacing Auto Scaling instances based on maximum
instance lifetime in the Amazon EC2 Auto Scaling User Guide.
- `"MaxSize"`: The maximum size of the Auto Scaling group. With a mixed instances policy
that uses instance weighting, Amazon EC2 Auto Scaling may need to go above MaxSize to meet
your capacity requirements. In this event, Amazon EC2 Auto Scaling will never go above
MaxSize by more than your largest instance weight (weights that define how many units each
instance contributes to the desired capacity of the group).
- `"MinSize"`: The minimum size of the Auto Scaling group.
- `"MixedInstancesPolicy"`: The mixed instances policy. For more information, see Auto
Scaling groups with multiple instance types and purchase options in the Amazon EC2 Auto
Scaling User Guide.
- `"NewInstancesProtectedFromScaleIn"`: Indicates whether newly launched instances are
protected from termination by Amazon EC2 Auto Scaling when scaling in. For more information
about preventing instances from terminating on scale in, see Use instance scale-in
protection in the Amazon EC2 Auto Scaling User Guide.
- `"PlacementGroup"`: The name of an existing placement group into which to launch your
instances. For more information, see Placement groups in the Amazon EC2 User Guide for
Linux Instances. A cluster placement group is a logical grouping of instances within a
single Availability Zone. You cannot specify multiple Availability Zones and a cluster
placement group.
- `"ServiceLinkedRoleARN"`: The Amazon Resource Name (ARN) of the service-linked role that
the Auto Scaling group uses to call other Amazon Web Services on your behalf. For more
information, see Service-linked roles in the Amazon EC2 Auto Scaling User Guide.
- `"TerminationPolicies"`: A policy or a list of policies that are used to select the
instances to terminate. The policies are executed in the order that you list them. For more
information, see Configure termination policies for Amazon EC2 Auto Scaling in the Amazon
EC2 Auto Scaling User Guide. Valid values: Default | AllocationStrategy |
ClosestToNextInstanceHour | NewestInstance | OldestInstance | OldestLaunchConfiguration |
OldestLaunchTemplate | arn:aws:lambda:region:account-id:function:my-function:my-alias
- `"VPCZoneIdentifier"`: A comma-separated list of subnet IDs for a virtual private cloud
(VPC). If you specify VPCZoneIdentifier with AvailabilityZones, the subnets that you
specify must reside in those Availability Zones.
"""
function update_auto_scaling_group(
AutoScalingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling(
"UpdateAutoScalingGroup",
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_auto_scaling_group(
AutoScalingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling(
"UpdateAutoScalingGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AutoScalingGroupName" => AutoScalingGroupName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 13051 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: auto_scaling_plans
using AWS.Compat
using AWS.UUIDs
"""
create_scaling_plan(application_source, scaling_instructions, scaling_plan_name)
create_scaling_plan(application_source, scaling_instructions, scaling_plan_name, params::Dict{String,<:Any})
Creates a scaling plan.
# Arguments
- `application_source`: A CloudFormation stack or set of tags. You can create one scaling
plan per application source. For more information, see ApplicationSource in the AWS Auto
Scaling API Reference.
- `scaling_instructions`: The scaling instructions. For more information, see
ScalingInstruction in the AWS Auto Scaling API Reference.
- `scaling_plan_name`: The name of the scaling plan. Names cannot contain vertical bars,
colons, or forward slashes.
"""
function create_scaling_plan(
ApplicationSource,
ScalingInstructions,
ScalingPlanName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"CreateScalingPlan",
Dict{String,Any}(
"ApplicationSource" => ApplicationSource,
"ScalingInstructions" => ScalingInstructions,
"ScalingPlanName" => ScalingPlanName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_scaling_plan(
ApplicationSource,
ScalingInstructions,
ScalingPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"CreateScalingPlan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ApplicationSource" => ApplicationSource,
"ScalingInstructions" => ScalingInstructions,
"ScalingPlanName" => ScalingPlanName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_scaling_plan(scaling_plan_name, scaling_plan_version)
delete_scaling_plan(scaling_plan_name, scaling_plan_version, params::Dict{String,<:Any})
Deletes the specified scaling plan. Deleting a scaling plan deletes the underlying
ScalingInstruction for all of the scalable resources that are covered by the plan. If the
plan has launched resources or has scaling activities in progress, you must delete those
resources separately.
# Arguments
- `scaling_plan_name`: The name of the scaling plan.
- `scaling_plan_version`: The version number of the scaling plan. Currently, the only valid
value is 1.
"""
function delete_scaling_plan(
ScalingPlanName, ScalingPlanVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling_plans(
"DeleteScalingPlan",
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName, "ScalingPlanVersion" => ScalingPlanVersion
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scaling_plan(
ScalingPlanName,
ScalingPlanVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"DeleteScalingPlan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName,
"ScalingPlanVersion" => ScalingPlanVersion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_plan_resources(scaling_plan_name, scaling_plan_version)
describe_scaling_plan_resources(scaling_plan_name, scaling_plan_version, params::Dict{String,<:Any})
Describes the scalable resources in the specified scaling plan.
# Arguments
- `scaling_plan_name`: The name of the scaling plan.
- `scaling_plan_version`: The version number of the scaling plan. Currently, the only valid
value is 1.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of scalable resources to return. The value must be
between 1 and 50. The default value is 50.
- `"NextToken"`: The token for the next set of results.
"""
function describe_scaling_plan_resources(
ScalingPlanName, ScalingPlanVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling_plans(
"DescribeScalingPlanResources",
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName, "ScalingPlanVersion" => ScalingPlanVersion
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scaling_plan_resources(
ScalingPlanName,
ScalingPlanVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"DescribeScalingPlanResources",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName,
"ScalingPlanVersion" => ScalingPlanVersion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_plans()
describe_scaling_plans(params::Dict{String,<:Any})
Describes one or more of your scaling plans.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApplicationSources"`: The sources for the applications (up to 10). If you specify
scaling plan names, you cannot specify application sources.
- `"MaxResults"`: The maximum number of scalable resources to return. This value can be
between 1 and 50. The default value is 50.
- `"NextToken"`: The token for the next set of results.
- `"ScalingPlanNames"`: The names of the scaling plans (up to 10). If you specify
application sources, you cannot specify scaling plan names.
- `"ScalingPlanVersion"`: The version number of the scaling plan. Currently, the only valid
value is 1. If you specify a scaling plan version, you must also specify a scaling plan
name.
"""
function describe_scaling_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return auto_scaling_plans(
"DescribeScalingPlans"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_scaling_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling_plans(
"DescribeScalingPlans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_scaling_plan_resource_forecast_data(end_time, forecast_data_type, resource_id, scalable_dimension, scaling_plan_name, scaling_plan_version, service_namespace, start_time)
get_scaling_plan_resource_forecast_data(end_time, forecast_data_type, resource_id, scalable_dimension, scaling_plan_name, scaling_plan_version, service_namespace, start_time, params::Dict{String,<:Any})
Retrieves the forecast data for a scalable resource. Capacity forecasts are represented as
predicted values, or data points, that are calculated using historical data points from a
specified CloudWatch load metric. Data points are available for up to 56 days.
# Arguments
- `end_time`: The exclusive end time of the time range for the forecast data to get. The
maximum time duration between the start and end time is seven days. Although this
parameter can accept a date and time that is more than two days in the future, the
availability of forecast data has limits. AWS Auto Scaling only issues forecasts for
periods of two days in advance.
- `forecast_data_type`: The type of forecast data to get. LoadForecast: The load metric
forecast. CapacityForecast: The capacity forecast. ScheduledActionMinCapacity: The
minimum capacity for each scheduled scaling action. This data is calculated as the larger
of two values: the capacity forecast or the minimum capacity in the scaling instruction.
ScheduledActionMaxCapacity: The maximum capacity for each scheduled scaling action. The
calculation used is determined by the predictive scaling maximum capacity behavior setting
in the scaling instruction.
- `resource_id`: The ID of the resource. This string consists of a prefix
(autoScalingGroup) followed by the name of a specified Auto Scaling group (my-asg).
Example: autoScalingGroup/my-asg.
- `scalable_dimension`: The scalable dimension for the resource. The only valid value is
autoscaling:autoScalingGroup:DesiredCapacity.
- `scaling_plan_name`: The name of the scaling plan.
- `scaling_plan_version`: The version number of the scaling plan. Currently, the only valid
value is 1.
- `service_namespace`: The namespace of the AWS service. The only valid value is
autoscaling.
- `start_time`: The inclusive start time of the time range for the forecast data to get.
The date and time can be at most 56 days before the current date and time.
"""
function get_scaling_plan_resource_forecast_data(
EndTime,
ForecastDataType,
ResourceId,
ScalableDimension,
ScalingPlanName,
ScalingPlanVersion,
ServiceNamespace,
StartTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"GetScalingPlanResourceForecastData",
Dict{String,Any}(
"EndTime" => EndTime,
"ForecastDataType" => ForecastDataType,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScalingPlanName" => ScalingPlanName,
"ScalingPlanVersion" => ScalingPlanVersion,
"ServiceNamespace" => ServiceNamespace,
"StartTime" => StartTime,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_scaling_plan_resource_forecast_data(
EndTime,
ForecastDataType,
ResourceId,
ScalableDimension,
ScalingPlanName,
ScalingPlanVersion,
ServiceNamespace,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"GetScalingPlanResourceForecastData",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"ForecastDataType" => ForecastDataType,
"ResourceId" => ResourceId,
"ScalableDimension" => ScalableDimension,
"ScalingPlanName" => ScalingPlanName,
"ScalingPlanVersion" => ScalingPlanVersion,
"ServiceNamespace" => ServiceNamespace,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_scaling_plan(scaling_plan_name, scaling_plan_version)
update_scaling_plan(scaling_plan_name, scaling_plan_version, params::Dict{String,<:Any})
Updates the specified scaling plan. You cannot update a scaling plan if it is in the
process of being created, updated, or deleted.
# Arguments
- `scaling_plan_name`: The name of the scaling plan.
- `scaling_plan_version`: The version number of the scaling plan. The only valid value is
1. Currently, you cannot have multiple scaling plan versions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ApplicationSource"`: A CloudFormation stack or set of tags. For more information, see
ApplicationSource in the AWS Auto Scaling API Reference.
- `"ScalingInstructions"`: The scaling instructions. For more information, see
ScalingInstruction in the AWS Auto Scaling API Reference.
"""
function update_scaling_plan(
ScalingPlanName, ScalingPlanVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return auto_scaling_plans(
"UpdateScalingPlan",
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName, "ScalingPlanVersion" => ScalingPlanVersion
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_scaling_plan(
ScalingPlanName,
ScalingPlanVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return auto_scaling_plans(
"UpdateScalingPlan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ScalingPlanName" => ScalingPlanName,
"ScalingPlanVersion" => ScalingPlanVersion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 40202 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: b2bi
using AWS.Compat
using AWS.UUIDs
"""
create_capability(configuration, name, type)
create_capability(configuration, name, type, params::Dict{String,<:Any})
Instantiates a capability based on the specified parameters. A trading capability contains
the information required to transform incoming EDI documents into JSON or XML outputs.
# Arguments
- `configuration`: Specifies a structure that contains the details for a capability.
- `name`: Specifies the name of the capability, used to identify it.
- `type`: Specifies the type of the capability. Currently, only edi is supported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Reserved for future use.
- `"instructionsDocuments"`: Specifies one or more locations in Amazon S3, each specifying
an EDI document that can be used with this capability. Each item contains the name of the
bucket and the key, to identify the document's location.
- `"tags"`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function create_capability(
configuration, name, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"CreateCapability",
Dict{String,Any}(
"configuration" => configuration,
"name" => name,
"type" => type,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_capability(
configuration,
name,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"CreateCapability",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configuration" => configuration,
"name" => name,
"type" => type,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_partnership(capabilities, email, name, profile_id)
create_partnership(capabilities, email, name, profile_id, params::Dict{String,<:Any})
Creates a partnership between a customer and a trading partner, based on the supplied
parameters. A partnership represents the connection between you and your trading partner.
It ties together a profile and one or more trading capabilities.
# Arguments
- `capabilities`: Specifies a list of the capabilities associated with this partnership.
- `email`: Specifies the email address associated with this trading partner.
- `name`: Specifies a descriptive name for the partnership.
- `profile_id`: Specifies the unique, system-generated identifier for the profile connected
to this partnership.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Reserved for future use.
- `"phone"`: Specifies the phone number associated with the partnership.
- `"tags"`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function create_partnership(
capabilities, email, name, profileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"CreatePartnership",
Dict{String,Any}(
"capabilities" => capabilities,
"email" => email,
"name" => name,
"profileId" => profileId,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_partnership(
capabilities,
email,
name,
profileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"CreatePartnership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"capabilities" => capabilities,
"email" => email,
"name" => name,
"profileId" => profileId,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_profile(business_name, logging, name, phone)
create_profile(business_name, logging, name, phone, params::Dict{String,<:Any})
Creates a customer profile. You can have up to five customer profiles, each representing a
distinct private network. A profile is the mechanism used to create the concept of a
private network.
# Arguments
- `business_name`: Specifies the name for the business associated with this profile.
- `logging`: Specifies whether or not logging is enabled for this profile.
- `name`: Specifies the name of the profile.
- `phone`: Specifies the phone number associated with the profile.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Reserved for future use.
- `"email"`: Specifies the email address associated with this customer profile.
- `"tags"`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function create_profile(
businessName, logging, name, phone; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"CreateProfile",
Dict{String,Any}(
"businessName" => businessName,
"logging" => logging,
"name" => name,
"phone" => phone,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_profile(
businessName,
logging,
name,
phone,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"CreateProfile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"businessName" => businessName,
"logging" => logging,
"name" => name,
"phone" => phone,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_transformer(edi_type, file_format, mapping_template, name)
create_transformer(edi_type, file_format, mapping_template, name, params::Dict{String,<:Any})
Creates a transformer. A transformer describes how to process the incoming EDI documents
and extract the necessary information to the output file.
# Arguments
- `edi_type`: Specifies the details for the EDI standard that is being used for the
transformer. Currently, only X12 is supported. X12 is a set of standards and corresponding
messages that define specific business documents.
- `file_format`: Specifies that the currently supported file formats for EDI
transformations are JSON and XML.
- `mapping_template`: Specifies the mapping template for the transformer. This template is
used to map the parsed EDI file using JSONata or XSLT.
- `name`: Specifies the name of the transformer, used to identify it.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Reserved for future use.
- `"sampleDocument"`: Specifies a sample EDI document that is used by a transformer as a
guide for processing the EDI data.
- `"tags"`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function create_transformer(
ediType,
fileFormat,
mappingTemplate,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"CreateTransformer",
Dict{String,Any}(
"ediType" => ediType,
"fileFormat" => fileFormat,
"mappingTemplate" => mappingTemplate,
"name" => name,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_transformer(
ediType,
fileFormat,
mappingTemplate,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"CreateTransformer",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ediType" => ediType,
"fileFormat" => fileFormat,
"mappingTemplate" => mappingTemplate,
"name" => name,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_capability(capability_id)
delete_capability(capability_id, params::Dict{String,<:Any})
Deletes the specified capability. A trading capability contains the information required to
transform incoming EDI documents into JSON or XML outputs.
# Arguments
- `capability_id`: Specifies a system-assigned unique identifier for the capability.
"""
function delete_capability(capabilityId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"DeleteCapability",
Dict{String,Any}("capabilityId" => capabilityId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_capability(
capabilityId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"DeleteCapability",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("capabilityId" => capabilityId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_partnership(partnership_id)
delete_partnership(partnership_id, params::Dict{String,<:Any})
Deletes the specified partnership. A partnership represents the connection between you and
your trading partner. It ties together a profile and one or more trading capabilities.
# Arguments
- `partnership_id`: Specifies the unique, system-generated identifier for a partnership.
"""
function delete_partnership(
partnershipId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"DeletePartnership",
Dict{String,Any}("partnershipId" => partnershipId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_partnership(
partnershipId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"DeletePartnership",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("partnershipId" => partnershipId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_profile(profile_id)
delete_profile(profile_id, params::Dict{String,<:Any})
Deletes the specified profile. A profile is the mechanism used to create the concept of a
private network.
# Arguments
- `profile_id`: Specifies the unique, system-generated identifier for the profile.
"""
function delete_profile(profileId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"DeleteProfile",
Dict{String,Any}("profileId" => profileId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_profile(
profileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"DeleteProfile",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("profileId" => profileId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_transformer(transformer_id)
delete_transformer(transformer_id, params::Dict{String,<:Any})
Deletes the specified transformer. A transformer describes how to process the incoming EDI
documents and extract the necessary information to the output file.
# Arguments
- `transformer_id`: Specifies the system-assigned unique identifier for the transformer.
"""
function delete_transformer(
transformerId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"DeleteTransformer",
Dict{String,Any}("transformerId" => transformerId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_transformer(
transformerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"DeleteTransformer",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("transformerId" => transformerId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_capability(capability_id)
get_capability(capability_id, params::Dict{String,<:Any})
Retrieves the details for the specified capability. A trading capability contains the
information required to transform incoming EDI documents into JSON or XML outputs.
# Arguments
- `capability_id`: Specifies a system-assigned unique identifier for the capability.
"""
function get_capability(capabilityId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"GetCapability",
Dict{String,Any}("capabilityId" => capabilityId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_capability(
capabilityId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"GetCapability",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("capabilityId" => capabilityId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_partnership(partnership_id)
get_partnership(partnership_id, params::Dict{String,<:Any})
Retrieves the details for a partnership, based on the partner and profile IDs specified. A
partnership represents the connection between you and your trading partner. It ties
together a profile and one or more trading capabilities.
# Arguments
- `partnership_id`: Specifies the unique, system-generated identifier for a partnership.
"""
function get_partnership(partnershipId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"GetPartnership",
Dict{String,Any}("partnershipId" => partnershipId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_partnership(
partnershipId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"GetPartnership",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("partnershipId" => partnershipId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_profile(profile_id)
get_profile(profile_id, params::Dict{String,<:Any})
Retrieves the details for the profile specified by the profile ID. A profile is the
mechanism used to create the concept of a private network.
# Arguments
- `profile_id`: Specifies the unique, system-generated identifier for the profile.
"""
function get_profile(profileId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"GetProfile",
Dict{String,Any}("profileId" => profileId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_profile(
profileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"GetProfile",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("profileId" => profileId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_transformer(transformer_id)
get_transformer(transformer_id, params::Dict{String,<:Any})
Retrieves the details for the transformer specified by the transformer ID. A transformer
describes how to process the incoming EDI documents and extract the necessary information
to the output file.
# Arguments
- `transformer_id`: Specifies the system-assigned unique identifier for the transformer.
"""
function get_transformer(transformerId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"GetTransformer",
Dict{String,Any}("transformerId" => transformerId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_transformer(
transformerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"GetTransformer",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("transformerId" => transformerId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_transformer_job(transformer_id, transformer_job_id)
get_transformer_job(transformer_id, transformer_job_id, params::Dict{String,<:Any})
Returns the details of the transformer run, based on the Transformer job ID.
# Arguments
- `transformer_id`: Specifies the system-assigned unique identifier for the transformer.
- `transformer_job_id`: Specifies the unique, system-generated identifier for a transformer
run.
"""
function get_transformer_job(
transformerId, transformerJobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"GetTransformerJob",
Dict{String,Any}(
"transformerId" => transformerId, "transformerJobId" => transformerJobId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_transformer_job(
transformerId,
transformerJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"GetTransformerJob",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"transformerId" => transformerId, "transformerJobId" => transformerJobId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_capabilities()
list_capabilities(params::Dict{String,<:Any})
Lists the capabilities associated with your Amazon Web Services account for your current or
specified region. A trading capability contains the information required to transform
incoming EDI documents into JSON or XML outputs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of capabilities to return.
- `"nextToken"`: When additional results are obtained from the command, a NextToken
parameter is returned in the output. You can then pass the NextToken parameter in a
subsequent command to continue listing additional resources.
"""
function list_capabilities(; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi("ListCapabilities"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_capabilities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"ListCapabilities", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_partnerships()
list_partnerships(params::Dict{String,<:Any})
Lists the partnerships associated with your Amazon Web Services account for your current or
specified region. A partnership represents the connection between you and your trading
partner. It ties together a profile and one or more trading capabilities.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of capabilities to return.
- `"nextToken"`: When additional results are obtained from the command, a NextToken
parameter is returned in the output. You can then pass the NextToken parameter in a
subsequent command to continue listing additional resources.
- `"profileId"`: Specifies the unique, system-generated identifier for the profile
connected to this partnership.
"""
function list_partnerships(; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi("ListPartnerships"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_partnerships(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"ListPartnerships", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_profiles()
list_profiles(params::Dict{String,<:Any})
Lists the profiles associated with your Amazon Web Services account for your current or
specified region. A profile is the mechanism used to create the concept of a private
network.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the maximum number of profiles to return.
- `"nextToken"`: When additional results are obtained from the command, a NextToken
parameter is returned in the output. You can then pass the NextToken parameter in a
subsequent command to continue listing additional resources.
"""
function list_profiles(; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi("ListProfiles"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_profiles(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"ListProfiles", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The
resource can be a capability, partnership, profile, or transformer.
# Arguments
- `resource_arn`: Requests the tags associated with a particular Amazon Resource Name
(ARN). An ARN is an identifier for a specific Amazon Web Services resource, such as a
capability, partnership, profile, or transformer.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_transformers()
list_transformers(params::Dict{String,<:Any})
Lists the available transformers. A transformer describes how to process the incoming EDI
documents and extract the necessary information to the output file.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Specifies the number of items to return for the API response.
- `"nextToken"`: When additional results are obtained from the command, a NextToken
parameter is returned in the output. You can then pass the NextToken parameter in a
subsequent command to continue listing additional resources.
"""
function list_transformers(; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi("ListTransformers"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_transformers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"ListTransformers", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
start_transformer_job(input_file, output_location, transformer_id)
start_transformer_job(input_file, output_location, transformer_id, params::Dict{String,<:Any})
Runs a job, using a transformer, to parse input EDI (electronic data interchange) file into
the output structures used by Amazon Web Services B2BI Data Interchange. If you only want
to transform EDI (electronic data interchange) documents, you don't need to create
profiles, partnerships or capabilities. Just create and configure a transformer, and then
run the StartTransformerJob API to process your files.
# Arguments
- `input_file`: Specifies the location of the input file for the transformation. The
location consists of an Amazon S3 bucket and prefix.
- `output_location`: Specifies the location of the output file for the transformation. The
location consists of an Amazon S3 bucket and prefix.
- `transformer_id`: Specifies the system-assigned unique identifier for the transformer.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Reserved for future use.
"""
function start_transformer_job(
inputFile,
outputLocation,
transformerId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"StartTransformerJob",
Dict{String,Any}(
"inputFile" => inputFile,
"outputLocation" => outputLocation,
"transformerId" => transformerId,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_transformer_job(
inputFile,
outputLocation,
transformerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"StartTransformerJob",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"inputFile" => inputFile,
"outputLocation" => outputLocation,
"transformerId" => transformerId,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN).
Resources are capability, partnership, profile, transformers and other entities. There is
no response returned from this call.
# Arguments
- `resource_arn`: Specifies an Amazon Resource Name (ARN) for a specific Amazon Web
Services resource, such as a capability, partnership, profile, or transformer.
- `tags`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_mapping(file_format, input_file_content, mapping_template)
test_mapping(file_format, input_file_content, mapping_template, params::Dict{String,<:Any})
Maps the input file according to the provided template file. The API call downloads the
file contents from the Amazon S3 location, and passes the contents in as a string, to the
inputFileContent parameter.
# Arguments
- `file_format`: Specifies that the currently supported file formats for EDI
transformations are JSON and XML.
- `input_file_content`: Specify the contents of the EDI (electronic data interchange) XML
or JSON file that is used as input for the transform.
- `mapping_template`: Specifies the mapping template for the transformer. This template is
used to map the parsed EDI file using JSONata or XSLT.
"""
function test_mapping(
fileFormat,
inputFileContent,
mappingTemplate;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"TestMapping",
Dict{String,Any}(
"fileFormat" => fileFormat,
"inputFileContent" => inputFileContent,
"mappingTemplate" => mappingTemplate,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_mapping(
fileFormat,
inputFileContent,
mappingTemplate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"TestMapping",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"fileFormat" => fileFormat,
"inputFileContent" => inputFileContent,
"mappingTemplate" => mappingTemplate,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_parsing(edi_type, file_format, input_file)
test_parsing(edi_type, file_format, input_file, params::Dict{String,<:Any})
Parses the input EDI (electronic data interchange) file. The input file has a file size
limit of 250 KB.
# Arguments
- `edi_type`: Specifies the details for the EDI standard that is being used for the
transformer. Currently, only X12 is supported. X12 is a set of standards and corresponding
messages that define specific business documents.
- `file_format`: Specifies that the currently supported file formats for EDI
transformations are JSON and XML.
- `input_file`: Specifies an S3Location object, which contains the Amazon S3 bucket and
prefix for the location of the input file.
"""
function test_parsing(
ediType, fileFormat, inputFile; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"TestParsing",
Dict{String,Any}(
"ediType" => ediType, "fileFormat" => fileFormat, "inputFile" => inputFile
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_parsing(
ediType,
fileFormat,
inputFile,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"TestParsing",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ediType" => ediType,
"fileFormat" => fileFormat,
"inputFile" => inputFile,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Detaches a key-value pair from the specified resource, as identified by its Amazon Resource
Name (ARN). Resources are capability, partnership, profile, transformers and other entities.
# Arguments
- `resource_arn`: Specifies an Amazon Resource Name (ARN) for a specific Amazon Web
Services resource, such as a capability, partnership, profile, or transformer.
- `tag_keys`: Specifies the key-value pairs assigned to ARNs that you can use to group and
search for resources by type. You can attach this metadata to resources (capabilities,
partnerships, and so on) for any purpose.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_capability(capability_id)
update_capability(capability_id, params::Dict{String,<:Any})
Updates some of the parameters for a capability, based on the specified parameters. A
trading capability contains the information required to transform incoming EDI documents
into JSON or XML outputs.
# Arguments
- `capability_id`: Specifies a system-assigned unique identifier for the capability.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"configuration"`: Specifies a structure that contains the details for a capability.
- `"instructionsDocuments"`: Specifies one or more locations in Amazon S3, each specifying
an EDI document that can be used with this capability. Each item contains the name of the
bucket and the key, to identify the document's location.
- `"name"`: Specifies a new name for the capability, to replace the existing name.
"""
function update_capability(capabilityId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"UpdateCapability",
Dict{String,Any}("capabilityId" => capabilityId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_capability(
capabilityId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"UpdateCapability",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("capabilityId" => capabilityId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_partnership(partnership_id)
update_partnership(partnership_id, params::Dict{String,<:Any})
Updates some of the parameters for a partnership between a customer and trading partner. A
partnership represents the connection between you and your trading partner. It ties
together a profile and one or more trading capabilities.
# Arguments
- `partnership_id`: Specifies the unique, system-generated identifier for a partnership.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"capabilities"`: List of the capabilities associated with this partnership.
- `"name"`: The name of the partnership, used to identify it.
"""
function update_partnership(
partnershipId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"UpdatePartnership",
Dict{String,Any}("partnershipId" => partnershipId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_partnership(
partnershipId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"UpdatePartnership",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("partnershipId" => partnershipId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_profile(profile_id)
update_profile(profile_id, params::Dict{String,<:Any})
Updates the specified parameters for a profile. A profile is the mechanism used to create
the concept of a private network.
# Arguments
- `profile_id`: Specifies the unique, system-generated identifier for the profile.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"businessName"`: Specifies the name for the business associated with this profile.
- `"email"`: Specifies the email address associated with this customer profile.
- `"name"`: The name of the profile, used to identify it.
- `"phone"`: Specifies the phone number associated with the profile.
"""
function update_profile(profileId; aws_config::AbstractAWSConfig=global_aws_config())
return b2bi(
"UpdateProfile",
Dict{String,Any}("profileId" => profileId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_profile(
profileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"UpdateProfile",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("profileId" => profileId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_transformer(transformer_id)
update_transformer(transformer_id, params::Dict{String,<:Any})
Updates the specified parameters for a transformer. A transformer describes how to process
the incoming EDI documents and extract the necessary information to the output file.
# Arguments
- `transformer_id`: Specifies the system-assigned unique identifier for the transformer.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ediType"`: Specifies the details for the EDI standard that is being used for the
transformer. Currently, only X12 is supported. X12 is a set of standards and corresponding
messages that define specific business documents.
- `"fileFormat"`: Specifies that the currently supported file formats for EDI
transformations are JSON and XML.
- `"mappingTemplate"`: Specifies the mapping template for the transformer. This template is
used to map the parsed EDI file using JSONata or XSLT.
- `"name"`: Specify a new name for the transformer, if you want to update it.
- `"sampleDocument"`: Specifies a sample EDI document that is used by a transformer as a
guide for processing the EDI data.
- `"status"`: Specifies the transformer's status. You can update the state of the
transformer, from active to inactive, or inactive to active.
"""
function update_transformer(
transformerId; aws_config::AbstractAWSConfig=global_aws_config()
)
return b2bi(
"UpdateTransformer",
Dict{String,Any}("transformerId" => transformerId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_transformer(
transformerId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return b2bi(
"UpdateTransformer",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("transformerId" => transformerId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 156752 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: backup
using AWS.Compat
using AWS.UUIDs
"""
cancel_legal_hold(cancel_description, legal_hold_id)
cancel_legal_hold(cancel_description, legal_hold_id, params::Dict{String,<:Any})
This action removes the specified legal hold on a recovery point. This action can only be
performed by a user with sufficient permissions.
# Arguments
- `cancel_description`: String describing the reason for removing the legal hold.
- `legal_hold_id`: Legal hold ID required to remove the specified legal hold on a recovery
point.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"retainRecordInDays"`: The integer amount in days specifying amount of days after this
API operation to remove legal hold.
"""
function cancel_legal_hold(
cancelDescription, legalHoldId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/legal-holds/$(legalHoldId)",
Dict{String,Any}("cancelDescription" => cancelDescription);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_legal_hold(
cancelDescription,
legalHoldId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/legal-holds/$(legalHoldId)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("cancelDescription" => cancelDescription), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backup_plan(backup_plan)
create_backup_plan(backup_plan, params::Dict{String,<:Any})
Creates a backup plan using a backup plan name and backup rules. A backup plan is a
document that contains information that Backup uses to schedule tasks that create recovery
points for resources. If you call CreateBackupPlan with a plan that already exists, you
receive an AlreadyExistsException exception.
# Arguments
- `backup_plan`: Specifies the body of a backup plan. Includes a BackupPlanName and one or
more sets of Rules.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupPlanTags"`: To help organize your resources, you can assign your own metadata to
the resources that you create. Each tag is a key-value pair. The specified tags are
assigned to all backups created with this plan.
- `"CreatorRequestId"`: Identifies the request and allows failed requests to be retried
without the risk of running the operation twice. If the request includes a CreatorRequestId
that matches an existing backup plan, that plan is returned. This parameter is optional. If
used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.
"""
function create_backup_plan(BackupPlan; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"PUT",
"/backup/plans/",
Dict{String,Any}("BackupPlan" => BackupPlan);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backup_plan(
BackupPlan,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup/plans/",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("BackupPlan" => BackupPlan), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backup_selection(backup_selection, backup_plan_id)
create_backup_selection(backup_selection, backup_plan_id, params::Dict{String,<:Any})
Creates a JSON document that specifies a set of resources to assign to a backup plan. For
examples, see Assigning resources programmatically.
# Arguments
- `backup_selection`: Specifies the body of a request to assign a set of resources to a
backup plan.
- `backup_plan_id`: Uniquely identifies the backup plan to be associated with the selection
of resources.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CreatorRequestId"`: A unique string that identifies the request and allows failed
requests to be retried without the risk of running the operation twice. This parameter is
optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.
"""
function create_backup_selection(
BackupSelection, backupPlanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/backup/plans/$(backupPlanId)/selections/",
Dict{String,Any}("BackupSelection" => BackupSelection);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backup_selection(
BackupSelection,
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup/plans/$(backupPlanId)/selections/",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("BackupSelection" => BackupSelection), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_backup_vault(backup_vault_name)
create_backup_vault(backup_vault_name, params::Dict{String,<:Any})
Creates a logical container where backups are stored. A CreateBackupVault request includes
a name, optionally one or more resource tags, an encryption key, and a request ID. Do not
include sensitive data, such as passport numbers, in the name of a backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of letters, numbers, and
hyphens.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupVaultTags"`: Metadata that you can assign to help organize the resources that you
create. Each tag is a key-value pair.
- `"CreatorRequestId"`: A unique string that identifies the request and allows failed
requests to be retried without the risk of running the operation twice. This parameter is
optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.
- `"EncryptionKeyArn"`: The server-side encryption key that is used to protect your
backups; for example,
arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.
"""
function create_backup_vault(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_backup_vault(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_framework(framework_controls, framework_name)
create_framework(framework_controls, framework_name, params::Dict{String,<:Any})
Creates a framework with one or more controls. A framework is a collection of controls that
you can use to evaluate your backup practices. By using pre-built customizable controls to
define your policies, you can evaluate whether your backup practices comply with your
policies and which resources are not yet in compliance.
# Arguments
- `framework_controls`: A list of the controls that make up the framework. Each control in
the list has a name, input parameters, and scope.
- `framework_name`: The unique name of the framework. The name must be between 1 and 256
characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9),
and underscores (_).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"FrameworkDescription"`: An optional description of the framework with a maximum of
1,024 characters.
- `"FrameworkTags"`: Metadata that you can assign to help organize the frameworks that you
create. Each tag is a key-value pair.
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to CreateFrameworkInput. Retrying a successful request with the
same idempotency token results in a success message with no action taken.
"""
function create_framework(
FrameworkControls, FrameworkName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/audit/frameworks",
Dict{String,Any}(
"FrameworkControls" => FrameworkControls,
"FrameworkName" => FrameworkName,
"IdempotencyToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_framework(
FrameworkControls,
FrameworkName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/audit/frameworks",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FrameworkControls" => FrameworkControls,
"FrameworkName" => FrameworkName,
"IdempotencyToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_legal_hold(description, title)
create_legal_hold(description, title, params::Dict{String,<:Any})
This action creates a legal hold on a recovery point (backup). A legal hold is a restraint
on altering or deleting a backup until an authorized user cancels the legal hold. Any
actions to delete or disassociate a recovery point will fail with an error if one or more
active legal holds are on the recovery point.
# Arguments
- `description`: This is the string description of the legal hold.
- `title`: This is the string title of the legal hold.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: This is a user-chosen string used to distinguish between otherwise
identical calls. Retrying a successful request with the same idempotency token results in a
success message with no action taken.
- `"RecoveryPointSelection"`: This specifies criteria to assign a set of resources, such as
resource types or backup vaults.
- `"Tags"`: Optional tags to include. A tag is a key-value pair you can use to manage,
filter, and search for your resources. Allowed characters include UTF-8 letters, numbers,
spaces, and the following characters: + - = . _ : /.
"""
function create_legal_hold(
Description, Title; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/legal-holds/",
Dict{String,Any}("Description" => Description, "Title" => Title);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_legal_hold(
Description,
Title,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/legal-holds/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Description" => Description, "Title" => Title),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_logically_air_gapped_backup_vault(max_retention_days, min_retention_days, backup_vault_name)
create_logically_air_gapped_backup_vault(max_retention_days, min_retention_days, backup_vault_name, params::Dict{String,<:Any})
This request creates a logical container to where backups may be copied. This request
includes a name, the Region, the maximum number of retention days, the minimum number of
retention days, and optionally can include tags and a creator request ID. Do not include
sensitive data, such as passport numbers, in the name of a backup vault.
# Arguments
- `max_retention_days`: This is the setting that specifies the maximum retention period
that the vault retains its recovery points. If this parameter is not specified, Backup does
not enforce a maximum retention period on the recovery points in the vault (allowing
indefinite storage). If specified, any backup or copy job to the vault must have a
lifecycle policy with a retention period equal to or shorter than the maximum retention
period. If the job retention period is longer than that maximum retention period, then the
vault fails the backup or copy job, and you should either modify your lifecycle settings or
use a different vault.
- `min_retention_days`: This setting specifies the minimum retention period that the vault
retains its recovery points. If this parameter is not specified, no minimum retention
period is enforced. If specified, any backup or copy job to the vault must have a lifecycle
policy with a retention period equal to or longer than the minimum retention period. If a
job retention period is shorter than that minimum retention period, then the vault fails
the backup or copy job, and you should either modify your lifecycle settings or use a
different vault.
- `backup_vault_name`: This is the name of the vault that is being created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupVaultTags"`: These are the tags that will be included in the newly-created vault.
- `"CreatorRequestId"`: This is the ID of the creation request. This parameter is optional.
If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.
"""
function create_logically_air_gapped_backup_vault(
MaxRetentionDays,
MinRetentionDays,
backupVaultName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/logically-air-gapped-backup-vaults/$(backupVaultName)",
Dict{String,Any}(
"MaxRetentionDays" => MaxRetentionDays, "MinRetentionDays" => MinRetentionDays
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_logically_air_gapped_backup_vault(
MaxRetentionDays,
MinRetentionDays,
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/logically-air-gapped-backup-vaults/$(backupVaultName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"MaxRetentionDays" => MaxRetentionDays,
"MinRetentionDays" => MinRetentionDays,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_report_plan(report_delivery_channel, report_plan_name, report_setting)
create_report_plan(report_delivery_channel, report_plan_name, report_setting, params::Dict{String,<:Any})
Creates a report plan. A report plan is a document that contains information about the
contents of the report and where Backup will deliver it. If you call CreateReportPlan with
a plan that already exists, you receive an AlreadyExistsException exception.
# Arguments
- `report_delivery_channel`: A structure that contains information about where and how to
deliver your reports, specifically your Amazon S3 bucket name, S3 key prefix, and the
formats of your reports.
- `report_plan_name`: The unique name of the report plan. The name must be between 1 and
256 characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers
(0-9), and underscores (_).
- `report_setting`: Identifies the report template for the report. Reports are built using
a report template. The report templates are: RESOURCE_COMPLIANCE_REPORT |
CONTROL_COMPLIANCE_REPORT | BACKUP_JOB_REPORT | COPY_JOB_REPORT | RESTORE_JOB_REPORT If
the report template is RESOURCE_COMPLIANCE_REPORT or CONTROL_COMPLIANCE_REPORT, this API
resource also describes the report coverage by Amazon Web Services Regions and frameworks.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to CreateReportPlanInput. Retrying a successful request with the
same idempotency token results in a success message with no action taken.
- `"ReportPlanDescription"`: An optional description of the report plan with a maximum of
1,024 characters.
- `"ReportPlanTags"`: Metadata that you can assign to help organize the report plans that
you create. Each tag is a key-value pair.
"""
function create_report_plan(
ReportDeliveryChannel,
ReportPlanName,
ReportSetting;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/audit/report-plans",
Dict{String,Any}(
"ReportDeliveryChannel" => ReportDeliveryChannel,
"ReportPlanName" => ReportPlanName,
"ReportSetting" => ReportSetting,
"IdempotencyToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_report_plan(
ReportDeliveryChannel,
ReportPlanName,
ReportSetting,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/audit/report-plans",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ReportDeliveryChannel" => ReportDeliveryChannel,
"ReportPlanName" => ReportPlanName,
"ReportSetting" => ReportSetting,
"IdempotencyToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_restore_testing_plan(restore_testing_plan)
create_restore_testing_plan(restore_testing_plan, params::Dict{String,<:Any})
This is the first of two steps to create a restore testing plan; once this request is
successful, finish the procedure with request CreateRestoreTestingSelection. You must
include the parameter RestoreTestingPlan. You may optionally include CreatorRequestId and
Tags.
# Arguments
- `restore_testing_plan`: A restore testing plan must contain a unique
RestoreTestingPlanName string you create and must contain a ScheduleExpression cron. You
may optionally include a StartWindowHours integer and a CreatorRequestId string. The
RestoreTestingPlanName is a unique string that is the name of the restore testing plan.
This cannot be changed after creation, and it must consist of only alphanumeric characters
and underscores.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CreatorRequestId"`: This is a unique string that identifies the request and allows
failed requests to be retriedwithout the risk of running the operation twice. This
parameter is optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.'
characters.
- `"Tags"`: Optional tags to include. A tag is a key-value pair you can use to manage,
filter, and search for your resources. Allowed characters include UTF-8 letters,numbers,
spaces, and the following characters: + - = . _ : /.
"""
function create_restore_testing_plan(
RestoreTestingPlan; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/restore-testing/plans",
Dict{String,Any}("RestoreTestingPlan" => RestoreTestingPlan);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_restore_testing_plan(
RestoreTestingPlan,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RestoreTestingPlan" => RestoreTestingPlan), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_restore_testing_selection(restore_testing_plan_name, restore_testing_selection)
create_restore_testing_selection(restore_testing_plan_name, restore_testing_selection, params::Dict{String,<:Any})
This request can be sent after CreateRestoreTestingPlan request returns successfully. This
is the second part of creating a resource testing plan, and it must be completed
sequentially. This consists of RestoreTestingSelectionName, ProtectedResourceType, and one
of the following: ProtectedResourceArns ProtectedResourceConditions Each
protected resource type can have one single value. A restore testing selection can include
a wildcard value (\"*\") for ProtectedResourceArns along with ProtectedResourceConditions.
Alternatively, you can include up to 30 specific protected resource ARNs in
ProtectedResourceArns. Cannot select by both protected resource types AND specific ARNs.
Request will fail if both are included.
# Arguments
- `restore_testing_plan_name`: Input the restore testing plan name that was returned from
the related CreateRestoreTestingPlan request.
- `restore_testing_selection`: This consists of RestoreTestingSelectionName,
ProtectedResourceType, and one of the following: ProtectedResourceArns
ProtectedResourceConditions Each protected resource type can have one single value. A
restore testing selection can include a wildcard value (\"*\") for ProtectedResourceArns
along with ProtectedResourceConditions. Alternatively, you can include up to 30 specific
protected resource ARNs in ProtectedResourceArns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CreatorRequestId"`: This is an optional unique string that identifies the request and
allows failed requests to be retried without the risk of running the operation twice. If
used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.
"""
function create_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelection;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections",
Dict{String,Any}("RestoreTestingSelection" => RestoreTestingSelection);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelection,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("RestoreTestingSelection" => RestoreTestingSelection),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_plan(backup_plan_id)
delete_backup_plan(backup_plan_id, params::Dict{String,<:Any})
Deletes a backup plan. A backup plan can only be deleted after all associated selections of
resources have been deleted. Deleting a backup plan deletes the current version of a backup
plan. Previous versions, if any, will still exist.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
"""
function delete_backup_plan(backupPlanId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"DELETE",
"/backup/plans/$(backupPlanId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_plan(
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup/plans/$(backupPlanId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_selection(backup_plan_id, selection_id)
delete_backup_selection(backup_plan_id, selection_id, params::Dict{String,<:Any})
Deletes the resource selection associated with a backup plan that is specified by the
SelectionId.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
- `selection_id`: Uniquely identifies the body of a request to assign a set of resources to
a backup plan.
"""
function delete_backup_selection(
backupPlanId, selectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup/plans/$(backupPlanId)/selections/$(selectionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_selection(
backupPlanId,
selectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup/plans/$(backupPlanId)/selections/$(selectionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_vault(backup_vault_name)
delete_backup_vault(backup_vault_name, params::Dict{String,<:Any})
Deletes the backup vault identified by its name. A vault can be deleted only if it is empty.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
"""
function delete_backup_vault(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_vault(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_vault_access_policy(backup_vault_name)
delete_backup_vault_access_policy(backup_vault_name, params::Dict{String,<:Any})
Deletes the policy document that manages permissions on a backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
"""
function delete_backup_vault_access_policy(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/access-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_vault_access_policy(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/access-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_vault_lock_configuration(backup_vault_name)
delete_backup_vault_lock_configuration(backup_vault_name, params::Dict{String,<:Any})
Deletes Backup Vault Lock from a backup vault specified by a backup vault name. If the
Vault Lock configuration is immutable, then you cannot delete Vault Lock using API
operations, and you will receive an InvalidRequestException if you attempt to do so. For
more information, see Vault Lock in the Backup Developer Guide.
# Arguments
- `backup_vault_name`: The name of the backup vault from which to delete Backup Vault Lock.
"""
function delete_backup_vault_lock_configuration(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/vault-lock";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_vault_lock_configuration(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/vault-lock",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup_vault_notifications(backup_vault_name)
delete_backup_vault_notifications(backup_vault_name, params::Dict{String,<:Any})
Deletes event notifications for the specified backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Region where they are created. They consist of lowercase letters, numbers, and hyphens.
"""
function delete_backup_vault_notifications(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/notification-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup_vault_notifications(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/notification-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_framework(framework_name)
delete_framework(framework_name, params::Dict{String,<:Any})
Deletes the framework specified by a framework name.
# Arguments
- `framework_name`: The unique name of a framework.
"""
function delete_framework(frameworkName; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"DELETE",
"/audit/frameworks/$(frameworkName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_framework(
frameworkName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/audit/frameworks/$(frameworkName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_recovery_point(backup_vault_name, recovery_point_arn)
delete_recovery_point(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
Deletes the recovery point specified by a recovery point ID. If the recovery point ID
belongs to a continuous backup, calling this endpoint deletes the existing continuous
backup and stops future continuous backup. When an IAM role's permissions are insufficient
to call this API, the service sends back an HTTP 200 response with an empty HTTP body, but
the recovery point is not deleted. Instead, it enters an EXPIRED state. EXPIRED recovery
points can be deleted with this API once the IAM role has the iam:CreateServiceLinkedRole
action. To learn more about adding this role, see Troubleshooting manual deletions. If the
user or role is deleted or the permission within the role is removed, the deletion will not
be successful and will enter an EXPIRED state.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies a recovery
point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
"""
function delete_recovery_point(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_recovery_point(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_report_plan(report_plan_name)
delete_report_plan(report_plan_name, params::Dict{String,<:Any})
Deletes the report plan specified by a report plan name.
# Arguments
- `report_plan_name`: The unique name of a report plan.
"""
function delete_report_plan(
reportPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/audit/report-plans/$(reportPlanName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_report_plan(
reportPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/audit/report-plans/$(reportPlanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_restore_testing_plan(restore_testing_plan_name)
delete_restore_testing_plan(restore_testing_plan_name, params::Dict{String,<:Any})
This request deletes the specified restore testing plan. Deletion can only successfully
occur if all associated restore testing selections are deleted first.
# Arguments
- `restore_testing_plan_name`: Required unique name of the restore testing plan you wish to
delete.
"""
function delete_restore_testing_plan(
RestoreTestingPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/restore-testing/plans/$(RestoreTestingPlanName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_restore_testing_plan(
RestoreTestingPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/restore-testing/plans/$(RestoreTestingPlanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_restore_testing_selection(restore_testing_plan_name, restore_testing_selection_name)
delete_restore_testing_selection(restore_testing_plan_name, restore_testing_selection_name, params::Dict{String,<:Any})
Input the Restore Testing Plan name and Restore Testing Selection name. All testing
selections associated with a restore testing plan must be deleted before the restore
testing plan can be deleted.
# Arguments
- `restore_testing_plan_name`: Required unique name of the restore testing plan that
contains the restore testing selection you wish to delete.
- `restore_testing_selection_name`: Required unique name of the restore testing selection
you wish to delete.
"""
function delete_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelectionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelectionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_backup_job(backup_job_id)
describe_backup_job(backup_job_id, params::Dict{String,<:Any})
Returns backup job details for the specified BackupJobId.
# Arguments
- `backup_job_id`: Uniquely identifies a request to Backup to back up a resource.
"""
function describe_backup_job(backupJobId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/backup-jobs/$(backupJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_backup_job(
backupJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-jobs/$(backupJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_backup_vault(backup_vault_name)
describe_backup_vault(backup_vault_name, params::Dict{String,<:Any})
Returns metadata about a backup vault specified by its name.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backupVaultAccountId"`: This is the account ID of the specified backup vault.
"""
function describe_backup_vault(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_backup_vault(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_copy_job(copy_job_id)
describe_copy_job(copy_job_id, params::Dict{String,<:Any})
Returns metadata associated with creating a copy of a resource.
# Arguments
- `copy_job_id`: Uniquely identifies a copy job.
"""
function describe_copy_job(copyJobId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/copy-jobs/$(copyJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_copy_job(
copyJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/copy-jobs/$(copyJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_framework(framework_name)
describe_framework(framework_name, params::Dict{String,<:Any})
Returns the framework details for the specified FrameworkName.
# Arguments
- `framework_name`: The unique name of a framework.
"""
function describe_framework(
frameworkName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/frameworks/$(frameworkName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_framework(
frameworkName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/audit/frameworks/$(frameworkName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_global_settings()
describe_global_settings(params::Dict{String,<:Any})
Describes whether the Amazon Web Services account is opted in to cross-account backup.
Returns an error if the account is not a member of an Organizations organization. Example:
describe-global-settings --region us-west-2
"""
function describe_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/global-settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/global-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_protected_resource(resource_arn)
describe_protected_resource(resource_arn, params::Dict{String,<:Any})
Returns information about a saved resource, including the last time it was backed up, its
Amazon Resource Name (ARN), and the Amazon Web Services service type of the saved resource.
# Arguments
- `resource_arn`: An Amazon Resource Name (ARN) that uniquely identifies a resource. The
format of the ARN depends on the resource type.
"""
function describe_protected_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/resources/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_protected_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/resources/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_recovery_point(backup_vault_name, recovery_point_arn)
describe_recovery_point(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
Returns metadata associated with a recovery point, including ID, status, encryption, and
lifecycle.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies a recovery
point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backupVaultAccountId"`: This is the account ID of the specified backup vault.
"""
function describe_recovery_point(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_recovery_point(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_region_settings()
describe_region_settings(params::Dict{String,<:Any})
Returns the current service opt-in settings for the Region. If service opt-in is enabled
for a service, Backup tries to protect that service's resources in this Region, when the
resource is included in an on-demand backup or scheduled backup plan. Otherwise, Backup
does not try to protect that service's resources in this Region.
"""
function describe_region_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/account-settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_region_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/account-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_report_job(report_job_id)
describe_report_job(report_job_id, params::Dict{String,<:Any})
Returns the details associated with creating a report as specified by its ReportJobId.
# Arguments
- `report_job_id`: The identifier of the report job. A unique, randomly generated, Unicode,
UTF-8 encoded string that is at most 1,024 bytes long. The report job ID cannot be edited.
"""
function describe_report_job(reportJobId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/audit/report-jobs/$(reportJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_report_job(
reportJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/audit/report-jobs/$(reportJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_report_plan(report_plan_name)
describe_report_plan(report_plan_name, params::Dict{String,<:Any})
Returns a list of all report plans for an Amazon Web Services account and Amazon Web
Services Region.
# Arguments
- `report_plan_name`: The unique name of a report plan.
"""
function describe_report_plan(
reportPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/report-plans/$(reportPlanName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_report_plan(
reportPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/audit/report-plans/$(reportPlanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_restore_job(restore_job_id)
describe_restore_job(restore_job_id, params::Dict{String,<:Any})
Returns metadata associated with a restore job that is specified by a job ID.
# Arguments
- `restore_job_id`: Uniquely identifies the job that restores a recovery point.
"""
function describe_restore_job(
restoreJobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-jobs/$(restoreJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_restore_job(
restoreJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-jobs/$(restoreJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_recovery_point(backup_vault_name, recovery_point_arn)
disassociate_recovery_point(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
Deletes the specified continuous backup recovery point from Backup and releases control of
that continuous backup to the source service, such as Amazon RDS. The source service will
continue to create and retain continuous backups using the lifecycle that you specified in
your original backup plan. Does not support snapshot backup recovery points.
# Arguments
- `backup_vault_name`: The unique name of an Backup vault.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies an Backup
recovery point.
"""
function disassociate_recovery_point(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/disassociate";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_recovery_point(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/disassociate",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_recovery_point_from_parent(backup_vault_name, recovery_point_arn)
disassociate_recovery_point_from_parent(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
This action to a specific child (nested) recovery point removes the relationship between
the specified recovery point and its parent (composite) recovery point.
# Arguments
- `backup_vault_name`: This is the name of a logical container where the child (nested)
recovery point is stored. Backup vaults are identified by names that are unique to the
account used to create them and the Amazon Web Services Region where they are created. They
consist of lowercase letters, numbers, and hyphens.
- `recovery_point_arn`: This is the Amazon Resource Name (ARN) that uniquely identifies the
child (nested) recovery point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
"""
function disassociate_recovery_point_from_parent(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/parentAssociation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_recovery_point_from_parent(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"DELETE",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/parentAssociation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
export_backup_plan_template(backup_plan_id)
export_backup_plan_template(backup_plan_id, params::Dict{String,<:Any})
Returns the backup plan that is specified by the plan ID as a backup template.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
"""
function export_backup_plan_template(
backupPlanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/toTemplate/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function export_backup_plan_template(
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/toTemplate/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_plan(backup_plan_id)
get_backup_plan(backup_plan_id, params::Dict{String,<:Any})
Returns BackupPlan details for the specified BackupPlanId. The details are the body of a
backup plan in JSON format, in addition to plan metadata.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"versionId"`: Unique, randomly generated, Unicode, UTF-8 encoded strings that are at
most 1,024 bytes long. Version IDs cannot be edited.
"""
function get_backup_plan(backupPlanId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/backup/plans/$(backupPlanId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_plan(
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_plan_from_json(backup_plan_template_json)
get_backup_plan_from_json(backup_plan_template_json, params::Dict{String,<:Any})
Returns a valid JSON document specifying a backup plan or an error.
# Arguments
- `backup_plan_template_json`: A customer-supplied backup plan document in JSON format.
"""
function get_backup_plan_from_json(
BackupPlanTemplateJson; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/backup/template/json/toPlan",
Dict{String,Any}("BackupPlanTemplateJson" => BackupPlanTemplateJson);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_plan_from_json(
BackupPlanTemplateJson,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/backup/template/json/toPlan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("BackupPlanTemplateJson" => BackupPlanTemplateJson),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_plan_from_template(template_id)
get_backup_plan_from_template(template_id, params::Dict{String,<:Any})
Returns the template specified by its templateId as a backup plan.
# Arguments
- `template_id`: Uniquely identifies a stored backup plan template.
"""
function get_backup_plan_from_template(
templateId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/template/plans/$(templateId)/toPlan";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_plan_from_template(
templateId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/template/plans/$(templateId)/toPlan",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_selection(backup_plan_id, selection_id)
get_backup_selection(backup_plan_id, selection_id, params::Dict{String,<:Any})
Returns selection metadata and a document in JSON format that specifies a list of resources
that are associated with a backup plan.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
- `selection_id`: Uniquely identifies the body of a request to assign a set of resources to
a backup plan.
"""
function get_backup_selection(
backupPlanId, selectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/selections/$(selectionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_selection(
backupPlanId,
selectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/selections/$(selectionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_vault_access_policy(backup_vault_name)
get_backup_vault_access_policy(backup_vault_name, params::Dict{String,<:Any})
Returns the access policy document that is associated with the named backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
"""
function get_backup_vault_access_policy(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/access-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_vault_access_policy(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/access-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_backup_vault_notifications(backup_vault_name)
get_backup_vault_notifications(backup_vault_name, params::Dict{String,<:Any})
Returns event notifications for the specified backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
"""
function get_backup_vault_notifications(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/notification-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_backup_vault_notifications(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/notification-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_legal_hold(legal_hold_id)
get_legal_hold(legal_hold_id, params::Dict{String,<:Any})
This action returns details for a specified legal hold. The details are the body of a legal
hold in JSON format, in addition to metadata.
# Arguments
- `legal_hold_id`: This is the ID required to use GetLegalHold. This unique ID is
associated with a specific legal hold.
"""
function get_legal_hold(legalHoldId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/legal-holds/$(legalHoldId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_legal_hold(
legalHoldId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/legal-holds/$(legalHoldId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_recovery_point_restore_metadata(backup_vault_name, recovery_point_arn)
get_recovery_point_restore_metadata(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
Returns a set of metadata key-value pairs that were used to create the backup.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies a recovery
point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backupVaultAccountId"`: This is the account ID of the specified backup vault.
"""
function get_recovery_point_restore_metadata(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/restore-metadata";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_recovery_point_restore_metadata(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)/restore-metadata",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_restore_job_metadata(restore_job_id)
get_restore_job_metadata(restore_job_id, params::Dict{String,<:Any})
This request returns the metadata for the specified restore job.
# Arguments
- `restore_job_id`: This is a unique identifier of a restore job within Backup.
"""
function get_restore_job_metadata(
restoreJobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-jobs/$(restoreJobId)/metadata";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_restore_job_metadata(
restoreJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-jobs/$(restoreJobId)/metadata",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_restore_testing_inferred_metadata(backup_vault_name, recovery_point_arn)
get_restore_testing_inferred_metadata(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
This request returns the minimal required set of metadata needed to start a restore job
with secure default settings. BackupVaultName and RecoveryPointArn are required parameters.
BackupVaultAccountId is an optional parameter.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web ServicesRegion where they are created. They consist of letters, numbers, and
hyphens.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies a recovery
point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupVaultAccountId"`: This is the account ID of the specified backup vault.
"""
function get_restore_testing_inferred_metadata(
BackupVaultName, RecoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-testing/inferred-metadata",
Dict{String,Any}(
"BackupVaultName" => BackupVaultName, "RecoveryPointArn" => RecoveryPointArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_restore_testing_inferred_metadata(
BackupVaultName,
RecoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-testing/inferred-metadata",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BackupVaultName" => BackupVaultName,
"RecoveryPointArn" => RecoveryPointArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_restore_testing_plan(restore_testing_plan_name)
get_restore_testing_plan(restore_testing_plan_name, params::Dict{String,<:Any})
Returns RestoreTestingPlan details for the specified RestoreTestingPlanName. The details
are the body of a restore testing plan in JSON format, in addition to plan metadata.
# Arguments
- `restore_testing_plan_name`: Required unique name of the restore testing plan.
"""
function get_restore_testing_plan(
RestoreTestingPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_restore_testing_plan(
RestoreTestingPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_restore_testing_selection(restore_testing_plan_name, restore_testing_selection_name)
get_restore_testing_selection(restore_testing_plan_name, restore_testing_selection_name, params::Dict{String,<:Any})
Returns RestoreTestingSelection, which displays resources and elements of the restore
testing plan.
# Arguments
- `restore_testing_plan_name`: Required unique name of the restore testing plan.
- `restore_testing_selection_name`: Required unique name of the restore testing selection.
"""
function get_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelectionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelectionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_supported_resource_types()
get_supported_resource_types(params::Dict{String,<:Any})
Returns the Amazon Web Services resource types supported by Backup.
"""
function get_supported_resource_types(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/supported-resource-types";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_supported_resource_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/supported-resource-types",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_job_summaries()
list_backup_job_summaries(params::Dict{String,<:Any})
This is a request for a summary of backup jobs created or running within the most recent 30
days. You can include parameters AccountID, State, ResourceType, MessageCategory,
AggregationPeriod, MaxResults, or NextToken to filter results. This request returns a
summary that contains Region, Account, State, ResourceType, MessageCategory, StartTime,
EndTime, and Count of included jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Returns the job count for the specified account. If the request is sent
from a member account or an account not part of Amazon Web Services Organizations, jobs
within requestor's account will be returned. Root, admin, and delegated administrator
accounts can use the value ANY to return job counts from every account in the organization.
AGGREGATE_ALL aggregates job counts from all accounts within the authenticated
organization, then returns the sum.
- `"AggregationPeriod"`: This is the period that sets the boundaries for returned results.
Acceptable values include ONE_DAY for daily job count for the prior 14 days.
SEVEN_DAYS for the aggregated job count for the prior 7 days. FOURTEEN_DAYS for
aggregated job count for prior 14 days.
- `"MaxResults"`: This parameter sets the maximum number of items to be returned. The value
is an integer. Range of accepted values is from 1 to 500.
- `"MessageCategory"`: This parameter returns the job count for the specified message
category. Example accepted strings include AccessDenied, Success, and InvalidParameters.
See Monitoring for a list of accepted MessageCategory strings. The the value ANY returns
count of all message categories. AGGREGATE_ALL aggregates job counts for all message
categories and returns the sum.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return MaxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
- `"ResourceType"`: Returns the job count for the specified resource type. Use request
GetSupportedResourceTypes to obtain strings for supported resource types. The the value ANY
returns count of all resource types. AGGREGATE_ALL aggregates job counts for all resource
types and returns the sum. The type of Amazon Web Services resource to be backed up; for
example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database
Service (Amazon RDS) database.
- `"State"`: This parameter returns the job count for jobs with the specified state. The
the value ANY returns count of all states. AGGREGATE_ALL aggregates job counts for all
states and returns the sum. Completed with issues is a status found only in the Backup
console. For API, this status refers to jobs with a state of COMPLETED and a
MessageCategory with a value other than SUCCESS; that is, the status is completed but comes
with a status message. To obtain the job count for Completed with issues, run two GET
requests, and subtract the second, smaller number: GET
/audit/backup-job-summaries?AggregationPeriod=FOURTEEN_DAYS&State=COMPLETED GET
/audit/backup-job-summaries?AggregationPeriod=FOURTEEN_DAYS&MessageCategory=SUCCESS&
;State=COMPLETED
"""
function list_backup_job_summaries(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/audit/backup-job-summaries";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backup_job_summaries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/backup-job-summaries",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_jobs()
list_backup_jobs(params::Dict{String,<:Any})
Returns a list of existing backup jobs for an authenticated account for the last 30 days.
For a longer period of time, consider using these monitoring tools.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accountId"`: The account ID to list the jobs from. Returns only backup jobs associated
with the specified account ID. If used from an Organizations management account, passing *
returns all jobs across the organization.
- `"backupVaultName"`: Returns only backup jobs that will be stored in the specified backup
vault. Backup vaults are identified by names that are unique to the account used to create
them and the Amazon Web Services Region where they are created. They consist of lowercase
letters, numbers, and hyphens.
- `"completeAfter"`: Returns only backup jobs completed after a date expressed in Unix
format and Coordinated Universal Time (UTC).
- `"completeBefore"`: Returns only backup jobs completed before a date expressed in Unix
format and Coordinated Universal Time (UTC).
- `"createdAfter"`: Returns only backup jobs that were created after the specified date.
- `"createdBefore"`: Returns only backup jobs that were created before the specified date.
- `"maxResults"`: The maximum number of items to be returned.
- `"messageCategory"`: This is an optional parameter that can be used to filter out jobs
with a MessageCategory which matches the value you input. Example strings may include
AccessDenied, SUCCESS, AGGREGATE_ALL, and InvalidParameters. View Monitoring The wildcard
() returns count of all message categories. AGGREGATE_ALL aggregates job counts for all
message categories and returns the sum.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"parentJobId"`: This is a filter to list child (nested) jobs based on parent job ID.
- `"resourceArn"`: Returns only backup jobs that match the specified resource Amazon
Resource Name (ARN).
- `"resourceType"`: Returns only backup jobs for the specified resources: Aurora for
Amazon Aurora CloudFormation for CloudFormation DocumentDB for Amazon DocumentDB
(with MongoDB compatibility) DynamoDB for Amazon DynamoDB EBS for Amazon Elastic
Block Store EC2 for Amazon Elastic Compute Cloud EFS for Amazon Elastic File System
FSx for Amazon FSx Neptune for Amazon Neptune Redshift for Amazon Redshift RDS
for Amazon Relational Database Service SAP HANA on Amazon EC2 for SAP HANA databases
Storage Gateway for Storage Gateway S3 for Amazon S3 Timestream for Amazon Timestream
VirtualMachine for virtual machines
- `"state"`: Returns only backup jobs that are in the specified state. Completed with
issues is a status found only in the Backup console. For API, this status refers to jobs
with a state of COMPLETED and a MessageCategory with a value other than SUCCESS; that is,
the status is completed but comes with a status message. To obtain the job count for
Completed with issues, run two GET requests, and subtract the second, smaller number: GET
/backup-jobs/?state=COMPLETED GET /backup-jobs/?messageCategory=SUCCESS&state=COMPLETED
"""
function list_backup_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/backup-jobs/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_backup_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-jobs/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_plan_templates()
list_backup_plan_templates(params::Dict{String,<:Any})
Returns metadata of your saved backup plan templates, including the template ID, name, and
the creation and deletion dates.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_backup_plan_templates(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/backup/template/plans";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backup_plan_templates(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/template/plans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_plan_versions(backup_plan_id)
list_backup_plan_versions(backup_plan_id, params::Dict{String,<:Any})
Returns version metadata of your backup plans, including Amazon Resource Names (ARNs),
backup plan IDs, creation and deletion dates, plan names, and version IDs.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_backup_plan_versions(
backupPlanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/versions/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backup_plan_versions(
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/versions/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_plans()
list_backup_plans(params::Dict{String,<:Any})
Returns a list of all active backup plans for an authenticated account. The list contains
information such as Amazon Resource Names (ARNs), plan IDs, creation and deletion dates,
version IDs, plan names, and creator request IDs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeDeleted"`: A Boolean value with a default value of FALSE that returns deleted
backup plans when set to TRUE.
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_backup_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/backup/plans/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_backup_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/plans/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_selections(backup_plan_id)
list_backup_selections(backup_plan_id, params::Dict{String,<:Any})
Returns an array containing metadata of the resources associated with the target backup
plan.
# Arguments
- `backup_plan_id`: Uniquely identifies a backup plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_backup_selections(
backupPlanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/selections/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_backup_selections(
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup/plans/$(backupPlanId)/selections/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_backup_vaults()
list_backup_vaults(params::Dict{String,<:Any})
Returns a list of recovery point storage containers along with information about them.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"shared"`: This parameter will sort the list of vaults by shared vaults.
- `"vaultType"`: This parameter will sort the list of vaults by vault type.
"""
function list_backup_vaults(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/backup-vaults/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_backup_vaults(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_copy_job_summaries()
list_copy_job_summaries(params::Dict{String,<:Any})
This request obtains a list of copy jobs created or running within the the most recent 30
days. You can include parameters AccountID, State, ResourceType, MessageCategory,
AggregationPeriod, MaxResults, or NextToken to filter results. This request returns a
summary that contains Region, Account, State, RestourceType, MessageCategory, StartTime,
EndTime, and Count of included jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Returns the job count for the specified account. If the request is sent
from a member account or an account not part of Amazon Web Services Organizations, jobs
within requestor's account will be returned. Root, admin, and delegated administrator
accounts can use the value ANY to return job counts from every account in the organization.
AGGREGATE_ALL aggregates job counts from all accounts within the authenticated
organization, then returns the sum.
- `"AggregationPeriod"`: This is the period that sets the boundaries for returned results.
ONE_DAY for daily job count for the prior 14 days. SEVEN_DAYS for the aggregated job
count for the prior 7 days. FOURTEEN_DAYS for aggregated job count for prior 14 days.
- `"MaxResults"`: This parameter sets the maximum number of items to be returned. The value
is an integer. Range of accepted values is from 1 to 500.
- `"MessageCategory"`: This parameter returns the job count for the specified message
category. Example accepted strings include AccessDenied, Success, and InvalidParameters.
See Monitoring for a list of accepted MessageCategory strings. The the value ANY returns
count of all message categories. AGGREGATE_ALL aggregates job counts for all message
categories and returns the sum.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return MaxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
- `"ResourceType"`: Returns the job count for the specified resource type. Use request
GetSupportedResourceTypes to obtain strings for supported resource types. The the value ANY
returns count of all resource types. AGGREGATE_ALL aggregates job counts for all resource
types and returns the sum. The type of Amazon Web Services resource to be backed up; for
example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database
Service (Amazon RDS) database.
- `"State"`: This parameter returns the job count for jobs with the specified state. The
the value ANY returns count of all states. AGGREGATE_ALL aggregates job counts for all
states and returns the sum.
"""
function list_copy_job_summaries(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/audit/copy-job-summaries";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_copy_job_summaries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/copy-job-summaries",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_copy_jobs()
list_copy_jobs(params::Dict{String,<:Any})
Returns metadata about your copy jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accountId"`: The account ID to list the jobs from. Returns only copy jobs associated
with the specified account ID.
- `"completeAfter"`: Returns only copy jobs completed after a date expressed in Unix format
and Coordinated Universal Time (UTC).
- `"completeBefore"`: Returns only copy jobs completed before a date expressed in Unix
format and Coordinated Universal Time (UTC).
- `"createdAfter"`: Returns only copy jobs that were created after the specified date.
- `"createdBefore"`: Returns only copy jobs that were created before the specified date.
- `"destinationVaultArn"`: An Amazon Resource Name (ARN) that uniquely identifies a source
backup vault to copy from; for example,
arn:aws:backup:us-east-1:123456789012:vault:aBackupVault.
- `"maxResults"`: The maximum number of items to be returned.
- `"messageCategory"`: This is an optional parameter that can be used to filter out jobs
with a MessageCategory which matches the value you input. Example strings may include
AccessDenied, SUCCESS, AGGREGATE_ALL, and INVALIDPARAMETERS. View Monitoring for a list of
accepted strings. The the value ANY returns count of all message categories. AGGREGATE_ALL
aggregates job counts for all message categories and returns the sum.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"parentJobId"`: This is a filter to list child (nested) jobs based on parent job ID.
- `"resourceArn"`: Returns only copy jobs that match the specified resource Amazon Resource
Name (ARN).
- `"resourceType"`: Returns only backup jobs for the specified resources: Aurora for
Amazon Aurora CloudFormation for CloudFormation DocumentDB for Amazon DocumentDB
(with MongoDB compatibility) DynamoDB for Amazon DynamoDB EBS for Amazon Elastic
Block Store EC2 for Amazon Elastic Compute Cloud EFS for Amazon Elastic File System
FSx for Amazon FSx Neptune for Amazon Neptune Redshift for Amazon Redshift RDS
for Amazon Relational Database Service SAP HANA on Amazon EC2 for SAP HANA databases
Storage Gateway for Storage Gateway S3 for Amazon S3 Timestream for Amazon Timestream
VirtualMachine for virtual machines
- `"state"`: Returns only copy jobs that are in the specified state.
"""
function list_copy_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/copy-jobs/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_copy_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET", "/copy-jobs/", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_frameworks()
list_frameworks(params::Dict{String,<:Any})
Returns a list of all frameworks for an Amazon Web Services account and Amazon Web Services
Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The number of desired results from 1 to 1000. Optional. If unspecified,
the query will return 1 MB of data.
- `"NextToken"`: An identifier that was returned from the previous call to this operation,
which can be used to return the next set of items in the list.
"""
function list_frameworks(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/audit/frameworks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_frameworks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/frameworks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_legal_holds()
list_legal_holds(params::Dict{String,<:Any})
This action returns metadata about active and previous legal holds.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of resource list items to be returned.
- `"nextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return MaxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
"""
function list_legal_holds(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/legal-holds/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_legal_holds(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/legal-holds/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_protected_resources()
list_protected_resources(params::Dict{String,<:Any})
Returns an array of resources successfully backed up by Backup, including the time the
resource was saved, an Amazon Resource Name (ARN) of the resource, and a resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_protected_resources(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/resources/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_protected_resources(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET", "/resources/", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_protected_resources_by_backup_vault(backup_vault_name)
list_protected_resources_by_backup_vault(backup_vault_name, params::Dict{String,<:Any})
This request lists the protected resources corresponding to each backup vault.
# Arguments
- `backup_vault_name`: This is the list of protected resources by backup vault within the
vault(s) you specify by name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backupVaultAccountId"`: This is the list of protected resources by backup vault within
the vault(s) you specify by account ID.
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_protected_resources_by_backup_vault(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/resources/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_protected_resources_by_backup_vault(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/resources/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_recovery_points_by_backup_vault(backup_vault_name)
list_recovery_points_by_backup_vault(backup_vault_name, params::Dict{String,<:Any})
Returns detailed information about the recovery points stored in a backup vault.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens. Backup vault name might not be available when a supported service
creates the backup.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"backupPlanId"`: Returns only recovery points that match the specified backup plan ID.
- `"backupVaultAccountId"`: This parameter will sort the list of recovery points by account
ID.
- `"createdAfter"`: Returns only recovery points that were created after the specified
timestamp.
- `"createdBefore"`: Returns only recovery points that were created before the specified
timestamp.
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"parentRecoveryPointArn"`: This returns only recovery points that match the specified
parent (composite) recovery point Amazon Resource Name (ARN).
- `"resourceArn"`: Returns only recovery points that match the specified resource Amazon
Resource Name (ARN).
- `"resourceType"`: Returns only recovery points that match the specified resource type(s):
Aurora for Amazon Aurora CloudFormation for CloudFormation DocumentDB for Amazon
DocumentDB (with MongoDB compatibility) DynamoDB for Amazon DynamoDB EBS for Amazon
Elastic Block Store EC2 for Amazon Elastic Compute Cloud EFS for Amazon Elastic File
System FSx for Amazon FSx Neptune for Amazon Neptune Redshift for Amazon Redshift
RDS for Amazon Relational Database Service SAP HANA on Amazon EC2 for SAP HANA
databases Storage Gateway for Storage Gateway S3 for Amazon S3 Timestream for
Amazon Timestream VirtualMachine for virtual machines
"""
function list_recovery_points_by_backup_vault(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_recovery_points_by_backup_vault(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/backup-vaults/$(backupVaultName)/recovery-points/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_recovery_points_by_legal_hold(legal_hold_id)
list_recovery_points_by_legal_hold(legal_hold_id, params::Dict{String,<:Any})
This action returns recovery point ARNs (Amazon Resource Names) of the specified legal hold.
# Arguments
- `legal_hold_id`: This is the ID of the legal hold.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: This is the maximum number of resource list items to be returned.
- `"nextToken"`: This is the next item following a partial list of returned resources. For
example, if a request is made to return MaxResults number of resources, NextToken allows
you to return more items in your list starting at the location pointed to by the next token.
"""
function list_recovery_points_by_legal_hold(
legalHoldId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/legal-holds/$(legalHoldId)/recovery-points";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_recovery_points_by_legal_hold(
legalHoldId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/legal-holds/$(legalHoldId)/recovery-points",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_recovery_points_by_resource(resource_arn)
list_recovery_points_by_resource(resource_arn, params::Dict{String,<:Any})
Returns detailed information about all the recovery points of the type specified by a
resource Amazon Resource Name (ARN). For Amazon EFS and Amazon EC2, this action only lists
recovery points created by Backup.
# Arguments
- `resource_arn`: An ARN that uniquely identifies a resource. The format of the ARN depends
on the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"managedByAWSBackupOnly"`: This attribute filters recovery points based on ownership. If
this is set to TRUE, the response will contain recovery points associated with the selected
resources that are managed by Backup. If this is set to FALSE, the response will contain
all recovery points associated with the selected resource. Type: Boolean
- `"maxResults"`: The maximum number of items to be returned. Amazon RDS requires a value
of at least 20.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_recovery_points_by_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/resources/$(resourceArn)/recovery-points/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_recovery_points_by_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/resources/$(resourceArn)/recovery-points/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_report_jobs()
list_report_jobs(params::Dict{String,<:Any})
Returns details about your report jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CreationAfter"`: Returns only report jobs that were created after the date and time
specified in Unix format and Coordinated Universal Time (UTC). For example, the value
1516925490 represents Friday, January 26, 2018 12:11:30 AM.
- `"CreationBefore"`: Returns only report jobs that were created before the date and time
specified in Unix format and Coordinated Universal Time (UTC). For example, the value
1516925490 represents Friday, January 26, 2018 12:11:30 AM.
- `"MaxResults"`: The number of desired results from 1 to 1000. Optional. If unspecified,
the query will return 1 MB of data.
- `"NextToken"`: An identifier that was returned from the previous call to this operation,
which can be used to return the next set of items in the list.
- `"ReportPlanName"`: Returns only report jobs with the specified report plan name.
- `"Status"`: Returns only report jobs that are in the specified status. The statuses are:
CREATED | RUNNING | COMPLETED | FAILED
"""
function list_report_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/audit/report-jobs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_report_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/report-jobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_report_plans()
list_report_plans(params::Dict{String,<:Any})
Returns a list of your report plans. For detailed information about a single report plan,
use DescribeReportPlan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The number of desired results from 1 to 1000. Optional. If unspecified,
the query will return 1 MB of data.
- `"NextToken"`: An identifier that was returned from the previous call to this operation,
which can be used to return the next set of items in the list.
"""
function list_report_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/audit/report-plans"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_report_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/report-plans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_restore_job_summaries()
list_restore_job_summaries(params::Dict{String,<:Any})
This request obtains a summary of restore jobs created or running within the the most
recent 30 days. You can include parameters AccountID, State, ResourceType,
AggregationPeriod, MaxResults, or NextToken to filter results. This request returns a
summary that contains Region, Account, State, RestourceType, MessageCategory, StartTime,
EndTime, and Count of included jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: Returns the job count for the specified account. If the request is sent
from a member account or an account not part of Amazon Web Services Organizations, jobs
within requestor's account will be returned. Root, admin, and delegated administrator
accounts can use the value ANY to return job counts from every account in the organization.
AGGREGATE_ALL aggregates job counts from all accounts within the authenticated
organization, then returns the sum.
- `"AggregationPeriod"`: This is the period that sets the boundaries for returned results.
Acceptable values include ONE_DAY for daily job count for the prior 14 days.
SEVEN_DAYS for the aggregated job count for the prior 7 days. FOURTEEN_DAYS for
aggregated job count for prior 14 days.
- `"MaxResults"`: This parameter sets the maximum number of items to be returned. The value
is an integer. Range of accepted values is from 1 to 500.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return MaxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
- `"ResourceType"`: Returns the job count for the specified resource type. Use request
GetSupportedResourceTypes to obtain strings for supported resource types. The the value ANY
returns count of all resource types. AGGREGATE_ALL aggregates job counts for all resource
types and returns the sum. The type of Amazon Web Services resource to be backed up; for
example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database
Service (Amazon RDS) database.
- `"State"`: This parameter returns the job count for jobs with the specified state. The
the value ANY returns count of all states. AGGREGATE_ALL aggregates job counts for all
states and returns the sum.
"""
function list_restore_job_summaries(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/audit/restore-job-summaries";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_restore_job_summaries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/audit/restore-job-summaries",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_restore_jobs()
list_restore_jobs(params::Dict{String,<:Any})
Returns a list of jobs that Backup initiated to restore a saved resource, including details
about the recovery process.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accountId"`: The account ID to list the jobs from. Returns only restore jobs associated
with the specified account ID.
- `"completeAfter"`: Returns only copy jobs completed after a date expressed in Unix format
and Coordinated Universal Time (UTC).
- `"completeBefore"`: Returns only copy jobs completed before a date expressed in Unix
format and Coordinated Universal Time (UTC).
- `"createdAfter"`: Returns only restore jobs that were created after the specified date.
- `"createdBefore"`: Returns only restore jobs that were created before the specified date.
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"resourceType"`: Include this parameter to return only restore jobs for the specified
resources: Aurora for Amazon Aurora CloudFormation for CloudFormation DocumentDB
for Amazon DocumentDB (with MongoDB compatibility) DynamoDB for Amazon DynamoDB EBS
for Amazon Elastic Block Store EC2 for Amazon Elastic Compute Cloud EFS for Amazon
Elastic File System FSx for Amazon FSx Neptune for Amazon Neptune Redshift for
Amazon Redshift RDS for Amazon Relational Database Service SAP HANA on Amazon EC2 for
SAP HANA databases Storage Gateway for Storage Gateway S3 for Amazon S3 Timestream
for Amazon Timestream VirtualMachine for virtual machines
- `"restoreTestingPlanArn"`: This returns only restore testing jobs that match the
specified resource Amazon Resource Name (ARN).
- `"status"`: Returns only restore jobs associated with the specified job status.
"""
function list_restore_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET", "/restore-jobs/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_restore_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-jobs/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_restore_jobs_by_protected_resource(resource_arn)
list_restore_jobs_by_protected_resource(resource_arn, params::Dict{String,<:Any})
This returns restore jobs that contain the specified protected resource. You must include
ResourceArn. You can optionally include NextToken, ByStatus, MaxResults,
ByRecoveryPointCreationDateAfter , and ByRecoveryPointCreationDateBefore.
# Arguments
- `resource_arn`: Returns only restore jobs that match the specified resource Amazon
Resource Name (ARN).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request ismade to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
- `"recoveryPointCreationDateAfter"`: Returns only restore jobs of recovery points that
were created after the specified date.
- `"recoveryPointCreationDateBefore"`: Returns only restore jobs of recovery points that
were created before the specified date.
- `"status"`: Returns only restore jobs associated with the specified job status.
"""
function list_restore_jobs_by_protected_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/resources/$(resourceArn)/restore-jobs/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_restore_jobs_by_protected_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/resources/$(resourceArn)/restore-jobs/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_restore_testing_plans()
list_restore_testing_plans(params::Dict{String,<:Any})
Returns a list of restore testing plans.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be returned.
- `"NextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the nexttoken.
"""
function list_restore_testing_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/restore-testing/plans";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_restore_testing_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-testing/plans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_restore_testing_selections(restore_testing_plan_name)
list_restore_testing_selections(restore_testing_plan_name, params::Dict{String,<:Any})
Returns a list of restore testing selections. Can be filtered by MaxResults and
RestoreTestingPlanName.
# Arguments
- `restore_testing_plan_name`: Returns restore testing selections by the specified restore
testing plan name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be returned.
- `"NextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the nexttoken.
"""
function list_restore_testing_selections(
RestoreTestingPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_restore_testing_selections(
RestoreTestingPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags(resource_arn)
list_tags(resource_arn, params::Dict{String,<:Any})
Returns a list of key-value pairs assigned to a target recovery point, backup plan, or
backup vault. ListTags only works for resource types that support full Backup management
of their backups. Those resource types are listed in the \"Full Backup management\" section
of the Feature availability by resource table.
# Arguments
- `resource_arn`: An Amazon Resource Name (ARN) that uniquely identifies a resource. The
format of the ARN depends on the type of resource. Valid targets for ListTags are recovery
points, backup plans, and backup vaults.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of items to be returned.
- `"nextToken"`: The next item following a partial list of returned items. For example, if
a request is made to return MaxResults number of items, NextToken allows you to return more
items in your list starting at the location pointed to by the next token.
"""
function list_tags(resourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"GET",
"/tags/$(resourceArn)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"GET",
"/tags/$(resourceArn)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_backup_vault_access_policy(backup_vault_name)
put_backup_vault_access_policy(backup_vault_name, params::Dict{String,<:Any})
Sets a resource-based policy that is used to manage access permissions on the target backup
vault. Requires a backup vault name and an access policy document in JSON format.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Policy"`: The backup vault access policy document in JSON format.
"""
function put_backup_vault_access_policy(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/access-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_backup_vault_access_policy(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/access-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_backup_vault_lock_configuration(backup_vault_name)
put_backup_vault_lock_configuration(backup_vault_name, params::Dict{String,<:Any})
Applies Backup Vault Lock to a backup vault, preventing attempts to delete any recovery
point stored in or created in a backup vault. Vault Lock also prevents attempts to update
the lifecycle policy that controls the retention period of any recovery point currently
stored in a backup vault. If specified, Vault Lock enforces a minimum and maximum retention
period for future backup and copy jobs that target a backup vault. Backup Vault Lock has
been assessed by Cohasset Associates for use in environments that are subject to SEC 17a-4,
CFTC, and FINRA regulations. For more information about how Backup Vault Lock relates to
these regulations, see the Cohasset Associates Compliance Assessment.
# Arguments
- `backup_vault_name`: The Backup Vault Lock configuration that specifies the name of the
backup vault it protects.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChangeableForDays"`: The Backup Vault Lock configuration that specifies the number of
days before the lock date. For example, setting ChangeableForDays to 30 on Jan. 1, 2022 at
8pm UTC will set the lock date to Jan. 31, 2022 at 8pm UTC. Backup enforces a 72-hour
cooling-off period before Vault Lock takes effect and becomes immutable. Therefore, you
must set ChangeableForDays to 3 or greater. Before the lock date, you can delete Vault Lock
from the vault using DeleteBackupVaultLockConfiguration or change the Vault Lock
configuration using PutBackupVaultLockConfiguration. On and after the lock date, the Vault
Lock becomes immutable and cannot be changed or deleted. If this parameter is not
specified, you can delete Vault Lock from the vault using
DeleteBackupVaultLockConfiguration or change the Vault Lock configuration using
PutBackupVaultLockConfiguration at any time.
- `"MaxRetentionDays"`: The Backup Vault Lock configuration that specifies the maximum
retention period that the vault retains its recovery points. This setting can be useful if,
for example, your organization's policies require you to destroy certain data after
retaining it for four years (1460 days). If this parameter is not included, Vault Lock does
not enforce a maximum retention period on the recovery points in the vault. If this
parameter is included without a value, Vault Lock will not enforce a maximum retention
period. If this parameter is specified, any backup or copy job to the vault must have a
lifecycle policy with a retention period equal to or shorter than the maximum retention
period. If the job's retention period is longer than that maximum retention period, then
the vault fails the backup or copy job, and you should either modify your lifecycle
settings or use a different vault. The longest maximum retention period you can specify is
36500 days (approximately 100 years). Recovery points already saved in the vault prior to
Vault Lock are not affected.
- `"MinRetentionDays"`: The Backup Vault Lock configuration that specifies the minimum
retention period that the vault retains its recovery points. This setting can be useful if,
for example, your organization's policies require you to retain certain data for at least
seven years (2555 days). If this parameter is not specified, Vault Lock will not enforce a
minimum retention period. If this parameter is specified, any backup or copy job to the
vault must have a lifecycle policy with a retention period equal to or longer than the
minimum retention period. If the job's retention period is shorter than that minimum
retention period, then the vault fails that backup or copy job, and you should either
modify your lifecycle settings or use a different vault. The shortest minimum retention
period you can specify is 1 day. Recovery points already saved in the vault prior to Vault
Lock are not affected.
"""
function put_backup_vault_lock_configuration(
backupVaultName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/vault-lock";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_backup_vault_lock_configuration(
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/vault-lock",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_backup_vault_notifications(backup_vault_events, snstopic_arn, backup_vault_name)
put_backup_vault_notifications(backup_vault_events, snstopic_arn, backup_vault_name, params::Dict{String,<:Any})
Turns on notifications on a backup vault for the specified topic and events.
# Arguments
- `backup_vault_events`: An array of events that indicate the status of jobs to back up
resources to the backup vault. For common use cases and code samples, see Using Amazon SNS
to track Backup events. The following events are supported: BACKUP_JOB_STARTED |
BACKUP_JOB_COMPLETED COPY_JOB_STARTED | COPY_JOB_SUCCESSFUL | COPY_JOB_FAILED
RESTORE_JOB_STARTED | RESTORE_JOB_COMPLETED | RECOVERY_POINT_MODIFIED
S3_BACKUP_OBJECT_FAILED | S3_RESTORE_OBJECT_FAILED The list below shows items that are
deprecated events (for reference) and are no longer in use. They are no longer supported
and will not return statuses or notifications. Refer to the list above for current
supported events.
- `snstopic_arn`: The Amazon Resource Name (ARN) that specifies the topic for a backup
vault’s events; for example, arn:aws:sns:us-west-2:111122223333:MyVaultTopic.
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
"""
function put_backup_vault_notifications(
BackupVaultEvents,
SNSTopicArn,
backupVaultName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/notification-configuration",
Dict{String,Any}(
"BackupVaultEvents" => BackupVaultEvents, "SNSTopicArn" => SNSTopicArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_backup_vault_notifications(
BackupVaultEvents,
SNSTopicArn,
backupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-vaults/$(backupVaultName)/notification-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BackupVaultEvents" => BackupVaultEvents, "SNSTopicArn" => SNSTopicArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_restore_validation_result(validation_status, restore_job_id)
put_restore_validation_result(validation_status, restore_job_id, params::Dict{String,<:Any})
This request allows you to send your independent self-run restore test validation results.
RestoreJobId and ValidationStatus are required. Optionally, you can input a
ValidationStatusMessage.
# Arguments
- `validation_status`: This is the status of your restore validation.
- `restore_job_id`: This is a unique identifier of a restore job within Backup.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ValidationStatusMessage"`: This is an optional message string you can input to describe
the validation status for the restore test validation.
"""
function put_restore_validation_result(
ValidationStatus, restoreJobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/restore-jobs/$(restoreJobId)/validations",
Dict{String,Any}("ValidationStatus" => ValidationStatus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_restore_validation_result(
ValidationStatus,
restoreJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-jobs/$(restoreJobId)/validations",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ValidationStatus" => ValidationStatus), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_backup_job(backup_vault_name, iam_role_arn, resource_arn)
start_backup_job(backup_vault_name, iam_role_arn, resource_arn, params::Dict{String,<:Any})
Starts an on-demand backup job for the specified resource.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
- `iam_role_arn`: Specifies the IAM role ARN used to create the target recovery point; for
example, arn:aws:iam::123456789012:role/S3Access.
- `resource_arn`: An Amazon Resource Name (ARN) that uniquely identifies a resource. The
format of the ARN depends on the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupOptions"`: Specifies the backup option for a selected resource. This option is
only available for Windows Volume Shadow Copy Service (VSS) backup jobs. Valid values: Set
to \"WindowsVSS\":\"enabled\" to enable the WindowsVSS backup option and create a Windows
VSS backup. Set to \"WindowsVSS\"\"disabled\" to create a regular backup. The WindowsVSS
option is not enabled by default.
- `"CompleteWindowMinutes"`: A value in minutes during which a successfully started backup
must complete, or else Backup will cancel the job. This value is optional. This value
begins counting down from when the backup was scheduled. It does not add additional time
for StartWindowMinutes, or if the backup started later than scheduled. Like
StartWindowMinutes, this parameter has a maximum value of 100 years (52,560,000 minutes).
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to StartBackupJob. Retrying a successful request with the same
idempotency token results in a success message with no action taken.
- `"Lifecycle"`: The lifecycle defines when a protected resource is transitioned to cold
storage and when it expires. Backup will transition and expire backups automatically
according to the lifecycle that you define. Backups transitioned to cold storage must be
stored in cold storage for a minimum of 90 days. Therefore, the “retention” setting
must be 90 days greater than the “transition to cold after days” setting. The
“transition to cold after days” setting cannot be changed after a backup has been
transitioned to cold. Resource types that are able to be transitioned to cold storage are
listed in the \"Lifecycle to cold storage\" section of the Feature availability by
resource table. Backup ignores this expression for other resource types. This parameter has
a maximum value of 100 years (36,500 days).
- `"RecoveryPointTags"`: To help organize your resources, you can assign your own metadata
to the resources that you create. Each tag is a key-value pair.
- `"StartWindowMinutes"`: A value in minutes after a backup is scheduled before a job will
be canceled if it doesn't start successfully. This value is optional, and the default is 8
hours. If this value is included, it must be at least 60 minutes to avoid errors. This
parameter has a maximum value of 100 years (52,560,000 minutes). During the start window,
the backup job status remains in CREATED status until it has successfully begun or until
the start window time has run out. If within the start window time Backup receives an error
that allows the job to be retried, Backup will automatically retry to begin the job at
least every 10 minutes until the backup successfully begins (the job status changes to
RUNNING) or until the job status changes to EXPIRED (which is expected to occur when the
start window time is over).
"""
function start_backup_job(
BackupVaultName,
IamRoleArn,
ResourceArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-jobs",
Dict{String,Any}(
"BackupVaultName" => BackupVaultName,
"IamRoleArn" => IamRoleArn,
"ResourceArn" => ResourceArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_backup_job(
BackupVaultName,
IamRoleArn,
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/backup-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BackupVaultName" => BackupVaultName,
"IamRoleArn" => IamRoleArn,
"ResourceArn" => ResourceArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_copy_job(destination_backup_vault_arn, iam_role_arn, recovery_point_arn, source_backup_vault_name)
start_copy_job(destination_backup_vault_arn, iam_role_arn, recovery_point_arn, source_backup_vault_name, params::Dict{String,<:Any})
Starts a job to create a one-time copy of the specified resource. Does not support
continuous backups.
# Arguments
- `destination_backup_vault_arn`: An Amazon Resource Name (ARN) that uniquely identifies a
destination backup vault to copy to; for example,
arn:aws:backup:us-east-1:123456789012:vault:aBackupVault.
- `iam_role_arn`: Specifies the IAM role ARN used to copy the target recovery point; for
example, arn:aws:iam::123456789012:role/S3Access.
- `recovery_point_arn`: An ARN that uniquely identifies a recovery point to use for the
copy job; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
- `source_backup_vault_name`: The name of a logical source container where backups are
stored. Backup vaults are identified by names that are unique to the account used to create
them and the Amazon Web Services Region where they are created. They consist of lowercase
letters, numbers, and hyphens.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to StartCopyJob. Retrying a successful request with the same
idempotency token results in a success message with no action taken.
- `"Lifecycle"`:
"""
function start_copy_job(
DestinationBackupVaultArn,
IamRoleArn,
RecoveryPointArn,
SourceBackupVaultName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/copy-jobs",
Dict{String,Any}(
"DestinationBackupVaultArn" => DestinationBackupVaultArn,
"IamRoleArn" => IamRoleArn,
"RecoveryPointArn" => RecoveryPointArn,
"SourceBackupVaultName" => SourceBackupVaultName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_copy_job(
DestinationBackupVaultArn,
IamRoleArn,
RecoveryPointArn,
SourceBackupVaultName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/copy-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DestinationBackupVaultArn" => DestinationBackupVaultArn,
"IamRoleArn" => IamRoleArn,
"RecoveryPointArn" => RecoveryPointArn,
"SourceBackupVaultName" => SourceBackupVaultName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_report_job(report_plan_name)
start_report_job(report_plan_name, params::Dict{String,<:Any})
Starts an on-demand report job for the specified report plan.
# Arguments
- `report_plan_name`: The unique name of a report plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to StartReportJobInput. Retrying a successful request with the
same idempotency token results in a success message with no action taken.
"""
function start_report_job(reportPlanName; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"POST",
"/audit/report-jobs/$(reportPlanName)",
Dict{String,Any}("IdempotencyToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_report_job(
reportPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/audit/report-jobs/$(reportPlanName)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("IdempotencyToken" => string(uuid4())), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_restore_job(metadata, recovery_point_arn)
start_restore_job(metadata, recovery_point_arn, params::Dict{String,<:Any})
Recovers the saved resource identified by an Amazon Resource Name (ARN).
# Arguments
- `metadata`: A set of metadata key-value pairs. Contains information, such as a resource
name, required to restore a recovery point. You can get configuration metadata about a
resource at the time it was backed up by calling GetRecoveryPointRestoreMetadata. However,
values in addition to those provided by GetRecoveryPointRestoreMetadata might be required
to restore a resource. For example, you might need to provide a new resource name if the
original already exists. You need to specify specific metadata to restore an Amazon Elastic
File System (Amazon EFS) instance: file-system-id: The ID of the Amazon EFS file system
that is backed up by Backup. Returned in GetRecoveryPointRestoreMetadata. Encrypted: A
Boolean value that, if true, specifies that the file system is encrypted. If KmsKeyId is
specified, Encrypted must be set to true. KmsKeyId: Specifies the Amazon Web Services
KMS key that is used to encrypt the restored file system. You can specify a key from
another Amazon Web Services account provided that key it is properly shared with your
account via Amazon Web Services KMS. PerformanceMode: Specifies the throughput mode of
the file system. CreationToken: A user-supplied value that ensures the uniqueness
(idempotency) of the request. newFileSystem: A Boolean value that, if true, specifies
that the recovery point is restored to a new Amazon EFS file system. ItemsToRestore: An
array of one to five strings where each string is a file path. Use ItemsToRestore to
restore specific files or directories rather than the entire file system. This parameter is
optional. For example, \"itemsToRestore\":\"[\"/my.test\"]\".
- `recovery_point_arn`: An ARN that uniquely identifies a recovery point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CopySourceTagsToRestoredResource"`: This is an optional parameter. If this equals True,
tags included in the backup will be copied to the restored resource. This can only be
applied to backups created through Backup.
- `"IamRoleArn"`: The Amazon Resource Name (ARN) of the IAM role that Backup uses to create
the target resource; for example: arn:aws:iam::123456789012:role/S3Access.
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to StartRestoreJob. Retrying a successful request with the same
idempotency token results in a success message with no action taken.
- `"ResourceType"`: Starts a job to restore a recovery point for one of the following
resources: Aurora for Amazon Aurora DocumentDB for Amazon DocumentDB (with MongoDB
compatibility) CloudFormation for CloudFormation DynamoDB for Amazon DynamoDB EBS
for Amazon Elastic Block Store EC2 for Amazon Elastic Compute Cloud EFS for Amazon
Elastic File System FSx for Amazon FSx Neptune for Amazon Neptune RDS for Amazon
Relational Database Service Redshift for Amazon Redshift Storage Gateway for Storage
Gateway S3 for Amazon S3 Timestream for Amazon Timestream VirtualMachine for
virtual machines
"""
function start_restore_job(
Metadata, RecoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/restore-jobs",
Dict{String,Any}("Metadata" => Metadata, "RecoveryPointArn" => RecoveryPointArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_restore_job(
Metadata,
RecoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Metadata" => Metadata, "RecoveryPointArn" => RecoveryPointArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_backup_job(backup_job_id)
stop_backup_job(backup_job_id, params::Dict{String,<:Any})
Attempts to cancel a job to create a one-time backup of a resource. This action is not
supported for the following services: Amazon FSx for Windows File Server, Amazon FSx for
Lustre, Amazon FSx for NetApp ONTAP , Amazon FSx for OpenZFS, Amazon DocumentDB (with
MongoDB compatibility), Amazon RDS, Amazon Aurora, and Amazon Neptune.
# Arguments
- `backup_job_id`: Uniquely identifies a request to Backup to back up a resource.
"""
function stop_backup_job(backupJobId; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"POST",
"/backup-jobs/$(backupJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_backup_job(
backupJobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/backup-jobs/$(backupJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(tags, resource_arn)
tag_resource(tags, resource_arn, params::Dict{String,<:Any})
Assigns a set of key-value pairs to a recovery point, backup plan, or backup vault
identified by an Amazon Resource Name (ARN).
# Arguments
- `tags`: Key-value pairs that are used to help organize your resources. You can assign
your own metadata to the resources you create. For clarity, this is the structure to assign
tags: [{\"Key\":\"string\",\"Value\":\"string\"}].
- `resource_arn`: An ARN that uniquely identifies a resource. The format of the ARN depends
on the type of the tagged resource.
"""
function tag_resource(Tags, resourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
Tags,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(tag_key_list, resource_arn)
untag_resource(tag_key_list, resource_arn, params::Dict{String,<:Any})
Removes a set of key-value pairs from a recovery point, backup plan, or backup vault
identified by an Amazon Resource Name (ARN)
# Arguments
- `tag_key_list`: A list of keys to identify which key-value tags to remove from a resource.
- `resource_arn`: An ARN that uniquely identifies a resource. The format of the ARN depends
on the type of the tagged resource.
"""
function untag_resource(
TagKeyList, resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/untag/$(resourceArn)",
Dict{String,Any}("TagKeyList" => TagKeyList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
TagKeyList,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/untag/$(resourceArn)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TagKeyList" => TagKeyList), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_backup_plan(backup_plan, backup_plan_id)
update_backup_plan(backup_plan, backup_plan_id, params::Dict{String,<:Any})
Updates an existing backup plan identified by its backupPlanId with the input document in
JSON format. The new version is uniquely identified by a VersionId.
# Arguments
- `backup_plan`: Specifies the body of a backup plan. Includes a BackupPlanName and one or
more sets of Rules.
- `backup_plan_id`: Uniquely identifies a backup plan.
"""
function update_backup_plan(
BackupPlan, backupPlanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/backup/plans/$(backupPlanId)",
Dict{String,Any}("BackupPlan" => BackupPlan);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_backup_plan(
BackupPlan,
backupPlanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/backup/plans/$(backupPlanId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("BackupPlan" => BackupPlan), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_framework(framework_name)
update_framework(framework_name, params::Dict{String,<:Any})
Updates an existing framework identified by its FrameworkName with the input document in
JSON format.
# Arguments
- `framework_name`: The unique name of a framework. This name is between 1 and 256
characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9),
and underscores (_).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"FrameworkControls"`: A list of the controls that make up the framework. Each control in
the list has a name, input parameters, and scope.
- `"FrameworkDescription"`: An optional description of the framework with a maximum 1,024
characters.
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to UpdateFrameworkInput. Retrying a successful request with the
same idempotency token results in a success message with no action taken.
"""
function update_framework(frameworkName; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"PUT",
"/audit/frameworks/$(frameworkName)",
Dict{String,Any}("IdempotencyToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_framework(
frameworkName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/audit/frameworks/$(frameworkName)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("IdempotencyToken" => string(uuid4())), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_global_settings()
update_global_settings(params::Dict{String,<:Any})
Updates whether the Amazon Web Services account is opted in to cross-account backup.
Returns an error if the account is not an Organizations management account. Use the
DescribeGlobalSettings API to determine the current settings.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"GlobalSettings"`: A value for isCrossAccountBackupEnabled and a Region. Example:
update-global-settings --global-settings isCrossAccountBackupEnabled=false --region
us-west-2.
"""
function update_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"PUT", "/global-settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/global-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_recovery_point_lifecycle(backup_vault_name, recovery_point_arn)
update_recovery_point_lifecycle(backup_vault_name, recovery_point_arn, params::Dict{String,<:Any})
Sets the transition lifecycle of a recovery point. The lifecycle defines when a protected
resource is transitioned to cold storage and when it expires. Backup transitions and
expires backups automatically according to the lifecycle that you define. Backups
transitioned to cold storage must be stored in cold storage for a minimum of 90 days.
Therefore, the “retention” setting must be 90 days greater than the “transition to
cold after days” setting. The “transition to cold after days” setting cannot be
changed after a backup has been transitioned to cold. Resource types that are able to be
transitioned to cold storage are listed in the \"Lifecycle to cold storage\" section of the
Feature availability by resource table. Backup ignores this expression for other resource
types. This operation does not support continuous backups.
# Arguments
- `backup_vault_name`: The name of a logical container where backups are stored. Backup
vaults are identified by names that are unique to the account used to create them and the
Amazon Web Services Region where they are created. They consist of lowercase letters,
numbers, and hyphens.
- `recovery_point_arn`: An Amazon Resource Name (ARN) that uniquely identifies a recovery
point; for example,
arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Lifecycle"`: The lifecycle defines when a protected resource is transitioned to cold
storage and when it expires. Backup transitions and expires backups automatically according
to the lifecycle that you define. Backups transitioned to cold storage must be stored in
cold storage for a minimum of 90 days. Therefore, the “retention” setting must be 90
days greater than the “transition to cold after days” setting. The “transition to
cold after days” setting cannot be changed after a backup has been transitioned to cold.
"""
function update_recovery_point_lifecycle(
backupVaultName, recoveryPointArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"POST",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_recovery_point_lifecycle(
backupVaultName,
recoveryPointArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"POST",
"/backup-vaults/$(backupVaultName)/recovery-points/$(recoveryPointArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_region_settings()
update_region_settings(params::Dict{String,<:Any})
Updates the current service opt-in settings for the Region. Use the DescribeRegionSettings
API to determine the resource types that are supported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ResourceTypeManagementPreference"`: Enables or disables full Backup management of
backups for a resource type. To enable full Backup management for DynamoDB along with
Backup's advanced DynamoDB backup features, follow the procedure to enable advanced
DynamoDB backup programmatically.
- `"ResourceTypeOptInPreference"`: Updates the list of services along with the opt-in
preferences for the Region. If resource assignments are only based on tags, then service
opt-in settings are applied. If a resource type is explicitly assigned to a backup plan,
such as Amazon S3, Amazon EC2, or Amazon RDS, it will be included in the backup even if the
opt-in is not enabled for that particular service. If both a resource type and tags are
specified in a resource assignment, the resource type specified in the backup plan takes
priority over the tag condition. Service opt-in settings are disregarded in this situation.
"""
function update_region_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return backup(
"PUT", "/account-settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_region_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/account-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_report_plan(report_plan_name)
update_report_plan(report_plan_name, params::Dict{String,<:Any})
Updates an existing report plan identified by its ReportPlanName with the input document in
JSON format.
# Arguments
- `report_plan_name`: The unique name of the report plan. This name is between 1 and 256
characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9),
and underscores (_).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IdempotencyToken"`: A customer-chosen string that you can use to distinguish between
otherwise identical calls to UpdateReportPlanInput. Retrying a successful request with the
same idempotency token results in a success message with no action taken.
- `"ReportDeliveryChannel"`: A structure that contains information about where to deliver
your reports, specifically your Amazon S3 bucket name, S3 key prefix, and the formats of
your reports.
- `"ReportPlanDescription"`: An optional description of the report plan with a maximum
1,024 characters.
- `"ReportSetting"`: Identifies the report template for the report. Reports are built using
a report template. The report templates are: RESOURCE_COMPLIANCE_REPORT |
CONTROL_COMPLIANCE_REPORT | BACKUP_JOB_REPORT | COPY_JOB_REPORT | RESTORE_JOB_REPORT If
the report template is RESOURCE_COMPLIANCE_REPORT or CONTROL_COMPLIANCE_REPORT, this API
resource also describes the report coverage by Amazon Web Services Regions and frameworks.
"""
function update_report_plan(
reportPlanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup(
"PUT",
"/audit/report-plans/$(reportPlanName)",
Dict{String,Any}("IdempotencyToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_report_plan(
reportPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/audit/report-plans/$(reportPlanName)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("IdempotencyToken" => string(uuid4())), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_restore_testing_plan(restore_testing_plan, restore_testing_plan_name)
update_restore_testing_plan(restore_testing_plan, restore_testing_plan_name, params::Dict{String,<:Any})
This request will send changes to your specified restore testing plan.
RestoreTestingPlanName cannot be updated after it is created. RecoveryPointSelection can
contain: Algorithm ExcludeVaults IncludeVaults RecoveryPointTypes
SelectionWindowDays
# Arguments
- `restore_testing_plan`: Specifies the body of a restore testing plan.
- `restore_testing_plan_name`: This is the restore testing plan name you wish to update.
"""
function update_restore_testing_plan(
RestoreTestingPlan,
RestoreTestingPlanName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)",
Dict{String,Any}("RestoreTestingPlan" => RestoreTestingPlan);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_restore_testing_plan(
RestoreTestingPlan,
RestoreTestingPlanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RestoreTestingPlan" => RestoreTestingPlan), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_restore_testing_selection(restore_testing_plan_name, restore_testing_selection, restore_testing_selection_name)
update_restore_testing_selection(restore_testing_plan_name, restore_testing_selection, restore_testing_selection_name, params::Dict{String,<:Any})
Most elements except the RestoreTestingSelectionName can be updated with this request.
RestoreTestingSelection can use either protected resource ARNs or conditions, but not both.
That is, if your selection has ProtectedResourceArns, requesting an update with the
parameter ProtectedResourceConditions will be unsuccessful.
# Arguments
- `restore_testing_plan_name`: The restore testing plan name is required to update the
indicated testing plan.
- `restore_testing_selection`: To update your restore testing selection, you can use either
protected resource ARNs or conditions, but not both. That is, if your selection has
ProtectedResourceArns, requesting an update with the parameter ProtectedResourceConditions
will be unsuccessful.
- `restore_testing_selection_name`: This is the required restore testing selection name of
the restore testing selection you wish to update.
"""
function update_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelection,
RestoreTestingSelectionName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)",
Dict{String,Any}("RestoreTestingSelection" => RestoreTestingSelection);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_restore_testing_selection(
RestoreTestingPlanName,
RestoreTestingSelection,
RestoreTestingSelectionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup(
"PUT",
"/restore-testing/plans/$(RestoreTestingPlanName)/selections/$(RestoreTestingSelectionName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("RestoreTestingSelection" => RestoreTestingSelection),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 32016 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: backup_gateway
using AWS.Compat
using AWS.UUIDs
"""
associate_gateway_to_server(gateway_arn, server_arn)
associate_gateway_to_server(gateway_arn, server_arn, params::Dict{String,<:Any})
Associates a backup gateway with your server. After you complete the association process,
you can back up and restore your VMs through the gateway.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway. Use the ListGateways
operation to return a list of gateways for your account and Amazon Web Services Region.
- `server_arn`: The Amazon Resource Name (ARN) of the server that hosts your virtual
machines.
"""
function associate_gateway_to_server(
GatewayArn, ServerArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"AssociateGatewayToServer",
Dict{String,Any}("GatewayArn" => GatewayArn, "ServerArn" => ServerArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_gateway_to_server(
GatewayArn,
ServerArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"AssociateGatewayToServer",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GatewayArn" => GatewayArn, "ServerArn" => ServerArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_gateway(activation_key, gateway_display_name, gateway_type)
create_gateway(activation_key, gateway_display_name, gateway_type, params::Dict{String,<:Any})
Creates a backup gateway. After you create a gateway, you can associate it with a server
using the AssociateGatewayToServer operation.
# Arguments
- `activation_key`: The activation key of the created gateway.
- `gateway_display_name`: The display name of the created gateway.
- `gateway_type`: The type of created gateway.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: A list of up to 50 tags to assign to the gateway. Each tag is a key-value pair.
"""
function create_gateway(
ActivationKey,
GatewayDisplayName,
GatewayType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"CreateGateway",
Dict{String,Any}(
"ActivationKey" => ActivationKey,
"GatewayDisplayName" => GatewayDisplayName,
"GatewayType" => GatewayType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_gateway(
ActivationKey,
GatewayDisplayName,
GatewayType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"CreateGateway",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ActivationKey" => ActivationKey,
"GatewayDisplayName" => GatewayDisplayName,
"GatewayType" => GatewayType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_gateway(gateway_arn)
delete_gateway(gateway_arn, params::Dict{String,<:Any})
Deletes a backup gateway.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway to delete.
"""
function delete_gateway(GatewayArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"DeleteGateway",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_gateway(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"DeleteGateway",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_hypervisor(hypervisor_arn)
delete_hypervisor(hypervisor_arn, params::Dict{String,<:Any})
Deletes a hypervisor.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor to delete.
"""
function delete_hypervisor(HypervisorArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"DeleteHypervisor",
Dict{String,Any}("HypervisorArn" => HypervisorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_hypervisor(
HypervisorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"DeleteHypervisor",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("HypervisorArn" => HypervisorArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_gateway_from_server(gateway_arn)
disassociate_gateway_from_server(gateway_arn, params::Dict{String,<:Any})
Disassociates a backup gateway from the specified server. After the disassociation process
finishes, the gateway can no longer access the virtual machines on the server.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway to disassociate.
"""
function disassociate_gateway_from_server(
GatewayArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"DisassociateGatewayFromServer",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_gateway_from_server(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"DisassociateGatewayFromServer",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_bandwidth_rate_limit_schedule(gateway_arn)
get_bandwidth_rate_limit_schedule(gateway_arn, params::Dict{String,<:Any})
Retrieves the bandwidth rate limit schedule for a specified gateway. By default, gateways
do not have bandwidth rate limit schedules, which means no bandwidth rate limiting is in
effect. Use this to get a gateway's bandwidth rate limit schedule.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway. Use the ListGateways
operation to return a list of gateways for your account and Amazon Web Services Region.
"""
function get_bandwidth_rate_limit_schedule(
GatewayArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"GetBandwidthRateLimitSchedule",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_bandwidth_rate_limit_schedule(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"GetBandwidthRateLimitSchedule",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_gateway(gateway_arn)
get_gateway(gateway_arn, params::Dict{String,<:Any})
By providing the ARN (Amazon Resource Name), this API returns the gateway.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway.
"""
function get_gateway(GatewayArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"GetGateway",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_gateway(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"GetGateway",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_hypervisor(hypervisor_arn)
get_hypervisor(hypervisor_arn, params::Dict{String,<:Any})
This action requests information about the specified hypervisor to which the gateway will
connect. A hypervisor is hardware, software, or firmware that creates and manages virtual
machines, and allocates resources to them.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor.
"""
function get_hypervisor(HypervisorArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"GetHypervisor",
Dict{String,Any}("HypervisorArn" => HypervisorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_hypervisor(
HypervisorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"GetHypervisor",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("HypervisorArn" => HypervisorArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_hypervisor_property_mappings(hypervisor_arn)
get_hypervisor_property_mappings(hypervisor_arn, params::Dict{String,<:Any})
This action retrieves the property mappings for the specified hypervisor. A hypervisor
property mapping displays the relationship of entity properties available from the
on-premises hypervisor to the properties available in Amazon Web Services.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor.
"""
function get_hypervisor_property_mappings(
HypervisorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"GetHypervisorPropertyMappings",
Dict{String,Any}("HypervisorArn" => HypervisorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_hypervisor_property_mappings(
HypervisorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"GetHypervisorPropertyMappings",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("HypervisorArn" => HypervisorArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_virtual_machine(resource_arn)
get_virtual_machine(resource_arn, params::Dict{String,<:Any})
By providing the ARN (Amazon Resource Name), this API returns the virtual machine.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the virtual machine.
"""
function get_virtual_machine(ResourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"GetVirtualMachine",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_virtual_machine(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"GetVirtualMachine",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_hypervisor_configuration(host, name)
import_hypervisor_configuration(host, name, params::Dict{String,<:Any})
Connect to a hypervisor by importing its configuration.
# Arguments
- `host`: The server host of the hypervisor. This can be either an IP address or a
fully-qualified domain name (FQDN).
- `name`: The name of the hypervisor.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"KmsKeyArn"`: The Key Management Service for the hypervisor.
- `"Password"`: The password for the hypervisor.
- `"Tags"`: The tags of the hypervisor configuration to import.
- `"Username"`: The username for the hypervisor.
"""
function import_hypervisor_configuration(
Host, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"ImportHypervisorConfiguration",
Dict{String,Any}("Host" => Host, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_hypervisor_configuration(
Host,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"ImportHypervisorConfiguration",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Host" => Host, "Name" => Name), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_gateways()
list_gateways(params::Dict{String,<:Any})
Lists backup gateways owned by an Amazon Web Services account in an Amazon Web Services
Region. The returned list is ordered by gateway Amazon Resource Name (ARN).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of gateways to list.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return MaxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
"""
function list_gateways(; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"ListGateways"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_gateways(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"ListGateways", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_hypervisors()
list_hypervisors(params::Dict{String,<:Any})
Lists your hypervisors.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of hypervisors to list.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return maxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
"""
function list_hypervisors(; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"ListHypervisors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_hypervisors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"ListHypervisors", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists the tags applied to the resource identified by its Amazon Resource Name (ARN).
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource's tags to list.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_virtual_machines()
list_virtual_machines(params::Dict{String,<:Any})
Lists your virtual machines.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"HypervisorArn"`: The Amazon Resource Name (ARN) of the hypervisor connected to your
virtual machine.
- `"MaxResults"`: The maximum number of virtual machines to list.
- `"NextToken"`: The next item following a partial list of returned resources. For example,
if a request is made to return maxResults number of resources, NextToken allows you to
return more items in your list starting at the location pointed to by the next token.
"""
function list_virtual_machines(; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"ListVirtualMachines"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_virtual_machines(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"ListVirtualMachines",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_bandwidth_rate_limit_schedule(bandwidth_rate_limit_intervals, gateway_arn)
put_bandwidth_rate_limit_schedule(bandwidth_rate_limit_intervals, gateway_arn, params::Dict{String,<:Any})
This action sets the bandwidth rate limit schedule for a specified gateway. By default,
gateways do not have a bandwidth rate limit schedule, which means no bandwidth rate
limiting is in effect. Use this to initiate a gateway's bandwidth rate limit schedule.
# Arguments
- `bandwidth_rate_limit_intervals`: An array containing bandwidth rate limit schedule
intervals for a gateway. When no bandwidth rate limit intervals have been scheduled, the
array is empty.
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway. Use the ListGateways
operation to return a list of gateways for your account and Amazon Web Services Region.
"""
function put_bandwidth_rate_limit_schedule(
BandwidthRateLimitIntervals,
GatewayArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"PutBandwidthRateLimitSchedule",
Dict{String,Any}(
"BandwidthRateLimitIntervals" => BandwidthRateLimitIntervals,
"GatewayArn" => GatewayArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_bandwidth_rate_limit_schedule(
BandwidthRateLimitIntervals,
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"PutBandwidthRateLimitSchedule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BandwidthRateLimitIntervals" => BandwidthRateLimitIntervals,
"GatewayArn" => GatewayArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_hypervisor_property_mappings(hypervisor_arn, iam_role_arn, vmware_to_aws_tag_mappings)
put_hypervisor_property_mappings(hypervisor_arn, iam_role_arn, vmware_to_aws_tag_mappings, params::Dict{String,<:Any})
This action sets the property mappings for the specified hypervisor. A hypervisor property
mapping displays the relationship of entity properties available from the on-premises
hypervisor to the properties available in Amazon Web Services.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor.
- `iam_role_arn`: The Amazon Resource Name (ARN) of the IAM role.
- `vmware_to_aws_tag_mappings`: This action requests the mappings of on-premises VMware
tags to the Amazon Web Services tags.
"""
function put_hypervisor_property_mappings(
HypervisorArn,
IamRoleArn,
VmwareToAwsTagMappings;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"PutHypervisorPropertyMappings",
Dict{String,Any}(
"HypervisorArn" => HypervisorArn,
"IamRoleArn" => IamRoleArn,
"VmwareToAwsTagMappings" => VmwareToAwsTagMappings,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_hypervisor_property_mappings(
HypervisorArn,
IamRoleArn,
VmwareToAwsTagMappings,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"PutHypervisorPropertyMappings",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"HypervisorArn" => HypervisorArn,
"IamRoleArn" => IamRoleArn,
"VmwareToAwsTagMappings" => VmwareToAwsTagMappings,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_maintenance_start_time(gateway_arn, hour_of_day, minute_of_hour)
put_maintenance_start_time(gateway_arn, hour_of_day, minute_of_hour, params::Dict{String,<:Any})
Set the maintenance start time for a gateway.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) for the gateway, used to specify its
maintenance start time.
- `hour_of_day`: The hour of the day to start maintenance on a gateway.
- `minute_of_hour`: The minute of the hour to start maintenance on a gateway.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DayOfMonth"`: The day of the month start maintenance on a gateway. Valid values range
from Sunday to Saturday.
- `"DayOfWeek"`: The day of the week to start maintenance on a gateway.
"""
function put_maintenance_start_time(
GatewayArn, HourOfDay, MinuteOfHour; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"PutMaintenanceStartTime",
Dict{String,Any}(
"GatewayArn" => GatewayArn,
"HourOfDay" => HourOfDay,
"MinuteOfHour" => MinuteOfHour,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_maintenance_start_time(
GatewayArn,
HourOfDay,
MinuteOfHour,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"PutMaintenanceStartTime",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"GatewayArn" => GatewayArn,
"HourOfDay" => HourOfDay,
"MinuteOfHour" => MinuteOfHour,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_virtual_machines_metadata_sync(hypervisor_arn)
start_virtual_machines_metadata_sync(hypervisor_arn, params::Dict{String,<:Any})
This action sends a request to sync metadata across the specified virtual machines.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor.
"""
function start_virtual_machines_metadata_sync(
HypervisorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"StartVirtualMachinesMetadataSync",
Dict{String,Any}("HypervisorArn" => HypervisorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_virtual_machines_metadata_sync(
HypervisorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"StartVirtualMachinesMetadataSync",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("HypervisorArn" => HypervisorArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tag the resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to tag.
- `tags`: A list of tags to assign to the resource.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_hypervisor_configuration(gateway_arn, host)
test_hypervisor_configuration(gateway_arn, host, params::Dict{String,<:Any})
Tests your hypervisor configuration to validate that backup gateway can connect with the
hypervisor and its resources.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway to the hypervisor to test.
- `host`: The server host of the hypervisor. This can be either an IP address or a
fully-qualified domain name (FQDN).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Password"`: The password for the hypervisor.
- `"Username"`: The username for the hypervisor.
"""
function test_hypervisor_configuration(
GatewayArn, Host; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"TestHypervisorConfiguration",
Dict{String,Any}("GatewayArn" => GatewayArn, "Host" => Host);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_hypervisor_configuration(
GatewayArn,
Host,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"TestHypervisorConfiguration",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("GatewayArn" => GatewayArn, "Host" => Host), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from the resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource from which to remove tags.
- `tag_keys`: The list of tag keys specifying which tags to remove.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_gateway_information(gateway_arn)
update_gateway_information(gateway_arn, params::Dict{String,<:Any})
Updates a gateway's name. Specify which gateway to update using the Amazon Resource Name
(ARN) of the gateway in your request.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"GatewayDisplayName"`: The updated display name of the gateway.
"""
function update_gateway_information(
GatewayArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"UpdateGatewayInformation",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_gateway_information(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"UpdateGatewayInformation",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_gateway_software_now(gateway_arn)
update_gateway_software_now(gateway_arn, params::Dict{String,<:Any})
Updates the gateway virtual machine (VM) software. The request immediately triggers the
software update. When you make this request, you get a 200 OK success response
immediately. However, it might take some time for the update to complete.
# Arguments
- `gateway_arn`: The Amazon Resource Name (ARN) of the gateway to be updated.
"""
function update_gateway_software_now(
GatewayArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return backup_gateway(
"UpdateGatewaySoftwareNow",
Dict{String,Any}("GatewayArn" => GatewayArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_gateway_software_now(
GatewayArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"UpdateGatewaySoftwareNow",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GatewayArn" => GatewayArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_hypervisor(hypervisor_arn)
update_hypervisor(hypervisor_arn, params::Dict{String,<:Any})
Updates a hypervisor metadata, including its host, username, and password. Specify which
hypervisor to update using the Amazon Resource Name (ARN) of the hypervisor in your request.
# Arguments
- `hypervisor_arn`: The Amazon Resource Name (ARN) of the hypervisor to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Host"`: The updated host of the hypervisor. This can be either an IP address or a
fully-qualified domain name (FQDN).
- `"LogGroupArn"`: The Amazon Resource Name (ARN) of the group of gateways within the
requested log.
- `"Name"`: The updated name for the hypervisor
- `"Password"`: The updated password for the hypervisor.
- `"Username"`: The updated username for the hypervisor.
"""
function update_hypervisor(HypervisorArn; aws_config::AbstractAWSConfig=global_aws_config())
return backup_gateway(
"UpdateHypervisor",
Dict{String,Any}("HypervisorArn" => HypervisorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_hypervisor(
HypervisorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return backup_gateway(
"UpdateHypervisor",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("HypervisorArn" => HypervisorArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 65853 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: batch
using AWS.Compat
using AWS.UUIDs
"""
cancel_job(job_id, reason)
cancel_job(job_id, reason, params::Dict{String,<:Any})
Cancels a job in an Batch job queue. Jobs that are in the SUBMITTED or PENDING are
canceled. A job inRUNNABLE remains in RUNNABLE until it reaches the head of the job queue.
Then the job status is updated to FAILED. A PENDING job is canceled after all dependency
jobs are completed. Therefore, it may take longer than expected to cancel a job in PENDING
status. When you try to cancel an array parent job in PENDING, Batch attempts to cancel all
child jobs. The array parent job is canceled when all child jobs are completed. Jobs that
progressed to the STARTING or RUNNING state aren't canceled. However, the API operation
still succeeds, even if no job is canceled. These jobs must be terminated with the
TerminateJob operation.
# Arguments
- `job_id`: The Batch job ID of the job to cancel.
- `reason`: A message to attach to the job that explains the reason for canceling it. This
message is returned by future DescribeJobs operations on the job. This message is also
recorded in the Batch activity logs.
"""
function cancel_job(jobId, reason; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/canceljob",
Dict{String,Any}("jobId" => jobId, "reason" => reason);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_job(
jobId,
reason,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/canceljob",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("jobId" => jobId, "reason" => reason), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_compute_environment(compute_environment_name, type)
create_compute_environment(compute_environment_name, type, params::Dict{String,<:Any})
Creates an Batch compute environment. You can create MANAGED or UNMANAGED compute
environments. MANAGED compute environments can use Amazon EC2 or Fargate resources.
UNMANAGED compute environments can only use EC2 resources. In a managed compute
environment, Batch manages the capacity and instance types of the compute resources within
the environment. This is based on the compute resource specification that you define or the
launch template that you specify when you create the compute environment. Either, you can
choose to use EC2 On-Demand Instances and EC2 Spot Instances. Or, you can use Fargate and
Fargate Spot capacity in your managed compute environment. You can optionally set a maximum
price so that Spot Instances only launch when the Spot Instance price is less than a
specified percentage of the On-Demand price. Multi-node parallel jobs aren't supported on
Spot Instances. In an unmanaged compute environment, you can manage your own EC2 compute
resources and have flexibility with how you configure your compute resources. For example,
you can use custom AMIs. However, you must verify that each of your AMIs meet the Amazon
ECS container instance AMI specification. For more information, see container instance AMIs
in the Amazon Elastic Container Service Developer Guide. After you created your unmanaged
compute environment, you can use the DescribeComputeEnvironments operation to find the
Amazon ECS cluster that's associated with it. Then, launch your container instances into
that Amazon ECS cluster. For more information, see Launching an Amazon ECS container
instance in the Amazon Elastic Container Service Developer Guide. To create a compute
environment that uses EKS resources, the caller must have permissions to call
eks:DescribeCluster. Batch doesn't automatically upgrade the AMIs in a compute
environment after it's created. For example, it also doesn't update the AMIs in your
compute environment when a newer version of the Amazon ECS optimized AMI is available.
You're responsible for the management of the guest operating system. This includes any
updates and security patches. You're also responsible for any additional application
software or utilities that you install on the compute resources. There are two ways to use
a new AMI for your Batch jobs. The original method is to complete these steps: Create a
new compute environment with the new AMI. Add the compute environment to an existing job
queue. Remove the earlier compute environment from your job queue. Delete the earlier
compute environment. In April 2022, Batch added enhanced support for updating compute
environments. For more information, see Updating compute environments. To use the enhanced
updating of compute environments to update AMIs, follow these rules: Either don't set the
service role (serviceRole) parameter or set it to the AWSBatchServiceRole service-linked
role. Set the allocation strategy (allocationStrategy) parameter to BEST_FIT_PROGRESSIVE,
SPOT_CAPACITY_OPTIMIZED, or SPOT_PRICE_CAPACITY_OPTIMIZED. Set the update to latest image
version (updateToLatestImageVersion) parameter to true. The updateToLatestImageVersion
parameter is used when you update a compute environment. This parameter is ignored when you
create a compute environment. Don't specify an AMI ID in imageId, imageIdOverride (in
ec2Configuration ), or in the launch template (launchTemplate). In that case, Batch selects
the latest Amazon ECS optimized AMI that's supported by Batch at the time the
infrastructure update is initiated. Alternatively, you can specify the AMI ID in the
imageId or imageIdOverride parameters, or the launch template identified by the
LaunchTemplate properties. Changing any of these properties starts an infrastructure
update. If the AMI ID is specified in the launch template, it can't be replaced by
specifying an AMI ID in either the imageId or imageIdOverride parameters. It can only be
replaced by specifying a different launch template, or if the launch template version is
set to Default or Latest, by setting either a new default version for the launch template
(if Default) or by adding a new version to the launch template (if Latest). If these
rules are followed, any update that starts an infrastructure update causes the AMI ID to be
re-selected. If the version setting in the launch template (launchTemplate) is set to
Latest or Default, the latest or default version of the launch template is evaluated up at
the time of the infrastructure update, even if the launchTemplate wasn't updated.
# Arguments
- `compute_environment_name`: The name for your compute environment. It can be up to 128
characters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and
underscores (_).
- `type`: The type of the compute environment: MANAGED or UNMANAGED. For more information,
see Compute Environments in the Batch User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computeResources"`: Details about the compute resources managed by the compute
environment. This parameter is required for managed compute environments. For more
information, see Compute Environments in the Batch User Guide.
- `"eksConfiguration"`: The details for the Amazon EKS cluster that supports the compute
environment.
- `"serviceRole"`: The full Amazon Resource Name (ARN) of the IAM role that allows Batch to
make calls to other Amazon Web Services services on your behalf. For more information, see
Batch service IAM role in the Batch User Guide. If your account already created the Batch
service-linked role, that role is used by default for your compute environment unless you
specify a different role here. If the Batch service-linked role doesn't exist in your
account, and no role is specified here, the service attempts to create the Batch
service-linked role in your account. If your specified role has a path other than /, then
you must specify either the full role ARN (recommended) or prefix the role name with the
path. For example, if a role with the name bar has a path of /foo/, specify /foo/bar as the
role name. For more information, see Friendly names and paths in the IAM User Guide.
Depending on how you created your Batch service role, its ARN might contain the
service-role path prefix. When you only specify the name of the service role, Batch assumes
that your ARN doesn't use the service-role path prefix. Because of this, we recommend that
you specify the full ARN of your service role when you create compute environments.
- `"state"`: The state of the compute environment. If the state is ENABLED, then the
compute environment accepts jobs from a queue and can scale out automatically based on
queues. If the state is ENABLED, then the Batch scheduler can attempt to place jobs from an
associated job queue on the compute resources within the environment. If the compute
environment is managed, then it can scale its instances out or in automatically, based on
the job queue demand. If the state is DISABLED, then the Batch scheduler doesn't attempt to
place jobs within the environment. Jobs in a STARTING or RUNNING state continue to progress
normally. Managed compute environments in the DISABLED state don't scale out. Compute
environments in a DISABLED state may continue to incur billing charges. To prevent
additional charges, turn off and then delete the compute environment. For more information,
see State in the Batch User Guide. When an instance is idle, the instance scales down to
the minvCpus value. However, the instance size doesn't change. For example, consider a
c5.8xlarge instance with a minvCpus value of 4 and a desiredvCpus value of 36. This
instance doesn't scale down to a c5.large instance.
- `"tags"`: The tags that you apply to the compute environment to help you categorize and
organize your resources. Each tag consists of a key and an optional value. For more
information, see Tagging Amazon Web Services Resources in Amazon Web Services General
Reference. These tags can be updated or removed using the TagResource and UntagResource API
operations. These tags don't propagate to the underlying compute resources.
- `"unmanagedvCpus"`: The maximum number of vCPUs for an unmanaged compute environment.
This parameter is only used for fair share scheduling to reserve vCPU capacity for new
share identifiers. If this parameter isn't provided for a fair share job queue, no vCPU
capacity is reserved. This parameter is only supported when the type parameter is set to
UNMANAGED.
"""
function create_compute_environment(
computeEnvironmentName, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/createcomputeenvironment",
Dict{String,Any}(
"computeEnvironmentName" => computeEnvironmentName, "type" => type
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_compute_environment(
computeEnvironmentName,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/createcomputeenvironment",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"computeEnvironmentName" => computeEnvironmentName, "type" => type
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_job_queue(compute_environment_order, job_queue_name, priority)
create_job_queue(compute_environment_order, job_queue_name, priority, params::Dict{String,<:Any})
Creates an Batch job queue. When you create a job queue, you associate one or more compute
environments to the queue and assign an order of preference for the compute environments.
You also set a priority to the job queue that determines the order that the Batch scheduler
places jobs onto its associated compute environments. For example, if a compute environment
is associated with more than one job queue, the job queue with a higher priority is given
preference for scheduling jobs to that compute environment.
# Arguments
- `compute_environment_order`: The set of compute environments mapped to a job queue and
their order relative to each other. The job scheduler uses this parameter to determine
which compute environment runs a specific job. Compute environments must be in the VALID
state before you can associate them with a job queue. You can associate up to three compute
environments with a job queue. All of the compute environments must be either EC2 (EC2 or
SPOT) or Fargate (FARGATE or FARGATE_SPOT); EC2 and Fargate compute environments can't be
mixed. All compute environments that are associated with a job queue must share the same
architecture. Batch doesn't support mixing compute environment architecture types in a
single job queue.
- `job_queue_name`: The name of the job queue. It can be up to 128 letters long. It can
contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
- `priority`: The priority of the job queue. Job queues with a higher priority (or a higher
integer value for the priority parameter) are evaluated first when associated with the same
compute environment. Priority is determined in descending order. For example, a job queue
with a priority value of 10 is given scheduling preference over a job queue with a priority
value of 1. All of the compute environments must be either EC2 (EC2 or SPOT) or Fargate
(FARGATE or FARGATE_SPOT); EC2 and Fargate compute environments can't be mixed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobStateTimeLimitActions"`: The set of actions that Batch performs on jobs that remain
at the head of the job queue in the specified state longer than specified times. Batch will
perform each action after maxTimeSeconds has passed.
- `"schedulingPolicyArn"`: The Amazon Resource Name (ARN) of the fair share scheduling
policy. If this parameter is specified, the job queue uses a fair share scheduling policy.
If this parameter isn't specified, the job queue uses a first in, first out (FIFO)
scheduling policy. After a job queue is created, you can replace but can't remove the fair
share scheduling policy. The format is
aws:Partition:batch:Region:Account:scheduling-policy/Name . An example is
aws:aws:batch:us-west-2:123456789012:scheduling-policy/MySchedulingPolicy.
- `"state"`: The state of the job queue. If the job queue state is ENABLED, it is able to
accept jobs. If the job queue state is DISABLED, new jobs can't be added to the queue, but
jobs already in the queue can finish.
- `"tags"`: The tags that you apply to the job queue to help you categorize and organize
your resources. Each tag consists of a key and an optional value. For more information, see
Tagging your Batch resources in Batch User Guide.
"""
function create_job_queue(
computeEnvironmentOrder,
jobQueueName,
priority;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/createjobqueue",
Dict{String,Any}(
"computeEnvironmentOrder" => computeEnvironmentOrder,
"jobQueueName" => jobQueueName,
"priority" => priority,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_job_queue(
computeEnvironmentOrder,
jobQueueName,
priority,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/createjobqueue",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"computeEnvironmentOrder" => computeEnvironmentOrder,
"jobQueueName" => jobQueueName,
"priority" => priority,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_scheduling_policy(name)
create_scheduling_policy(name, params::Dict{String,<:Any})
Creates an Batch scheduling policy.
# Arguments
- `name`: The name of the scheduling policy. It can be up to 128 letters long. It can
contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"fairsharePolicy"`: The fair share policy of the scheduling policy.
- `"tags"`: The tags that you apply to the scheduling policy to help you categorize and
organize your resources. Each tag consists of a key and an optional value. For more
information, see Tagging Amazon Web Services Resources in Amazon Web Services General
Reference. These tags can be updated or removed using the TagResource and UntagResource API
operations.
"""
function create_scheduling_policy(name; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/createschedulingpolicy",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_scheduling_policy(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/createschedulingpolicy",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_compute_environment(compute_environment)
delete_compute_environment(compute_environment, params::Dict{String,<:Any})
Deletes an Batch compute environment. Before you can delete a compute environment, you must
set its state to DISABLED with the UpdateComputeEnvironment API operation and disassociate
it from any job queues with the UpdateJobQueue API operation. Compute environments that use
Fargate resources must terminate all active jobs on that compute environment before
deleting the compute environment. If this isn't done, the compute environment enters an
invalid state.
# Arguments
- `compute_environment`: The name or Amazon Resource Name (ARN) of the compute environment
to delete.
"""
function delete_compute_environment(
computeEnvironment; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/deletecomputeenvironment",
Dict{String,Any}("computeEnvironment" => computeEnvironment);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_compute_environment(
computeEnvironment,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/deletecomputeenvironment",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("computeEnvironment" => computeEnvironment), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_job_queue(job_queue)
delete_job_queue(job_queue, params::Dict{String,<:Any})
Deletes the specified job queue. You must first disable submissions for a queue with the
UpdateJobQueue operation. All jobs in the queue are eventually terminated when you delete a
job queue. The jobs are terminated at a rate of about 16 jobs each second. It's not
necessary to disassociate compute environments from a queue before submitting a
DeleteJobQueue request.
# Arguments
- `job_queue`: The short name or full Amazon Resource Name (ARN) of the queue to delete.
"""
function delete_job_queue(jobQueue; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/deletejobqueue",
Dict{String,Any}("jobQueue" => jobQueue);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_job_queue(
jobQueue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/deletejobqueue",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("jobQueue" => jobQueue), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_scheduling_policy(arn)
delete_scheduling_policy(arn, params::Dict{String,<:Any})
Deletes the specified scheduling policy. You can't delete a scheduling policy that's used
in any job queues.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the scheduling policy to delete.
"""
function delete_scheduling_policy(arn; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/deleteschedulingpolicy",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_scheduling_policy(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/deleteschedulingpolicy",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_job_definition(job_definition)
deregister_job_definition(job_definition, params::Dict{String,<:Any})
Deregisters an Batch job definition. Job definitions are permanently deleted after 180 days.
# Arguments
- `job_definition`: The name and revision (name:revision) or full Amazon Resource Name
(ARN) of the job definition to deregister.
"""
function deregister_job_definition(
jobDefinition; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/deregisterjobdefinition",
Dict{String,Any}("jobDefinition" => jobDefinition);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_job_definition(
jobDefinition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/deregisterjobdefinition",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("jobDefinition" => jobDefinition), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_compute_environments()
describe_compute_environments(params::Dict{String,<:Any})
Describes one or more of your compute environments. If you're using an unmanaged compute
environment, you can use the DescribeComputeEnvironment operation to determine the
ecsClusterArn that you launch your Amazon ECS container instances into.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computeEnvironments"`: A list of up to 100 compute environment names or full Amazon
Resource Name (ARN) entries.
- `"maxResults"`: The maximum number of cluster results returned by
DescribeComputeEnvironments in paginated output. When this parameter is used,
DescribeComputeEnvironments only returns maxResults results in a single page along with a
nextToken response element. The remaining results of the initial request can be seen by
sending another DescribeComputeEnvironments request with the returned nextToken value. This
value can be between 1 and 100. If this parameter isn't used, then
DescribeComputeEnvironments returns up to 100 results and a nextToken value if applicable.
- `"nextToken"`: The nextToken value returned from a previous paginated
DescribeComputeEnvironments request where maxResults was used and the results exceeded the
value of that parameter. Pagination continues from the end of the previous results that
returned the nextToken value. This value is null when there are no more results to return.
Treat this token as an opaque identifier that's only used to retrieve the next items in a
list and not for other programmatic purposes.
"""
function describe_compute_environments(; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/describecomputeenvironments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_compute_environments(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describecomputeenvironments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_job_definitions()
describe_job_definitions(params::Dict{String,<:Any})
Describes a list of job definitions. You can specify a status (such as ACTIVE) to only
return job definitions that match that status.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobDefinitionName"`: The name of the job definition to describe.
- `"jobDefinitions"`: A list of up to 100 job definitions. Each entry in the list can
either be an ARN in the format
arn:aws:batch:{Region}:{Account}:job-definition/{JobDefinitionName}:{Revision} or a short
version using the form {JobDefinitionName}:{Revision}. This parameter can't be used with
other parameters.
- `"maxResults"`: The maximum number of results returned by DescribeJobDefinitions in
paginated output. When this parameter is used, DescribeJobDefinitions only returns
maxResults results in a single page and a nextToken response element. The remaining results
of the initial request can be seen by sending another DescribeJobDefinitions request with
the returned nextToken value. This value can be between 1 and 100. If this parameter isn't
used, then DescribeJobDefinitions returns up to 100 results and a nextToken value if
applicable.
- `"nextToken"`: The nextToken value returned from a previous paginated
DescribeJobDefinitions request where maxResults was used and the results exceeded the value
of that parameter. Pagination continues from the end of the previous results that returned
the nextToken value. This value is null when there are no more results to return. Treat
this token as an opaque identifier that's only used to retrieve the next items in a list
and not for other programmatic purposes.
- `"status"`: The status used to filter job definitions.
"""
function describe_job_definitions(; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/describejobdefinitions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_job_definitions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describejobdefinitions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_job_queues()
describe_job_queues(params::Dict{String,<:Any})
Describes one or more of your job queues.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobQueues"`: A list of up to 100 queue names or full queue Amazon Resource Name (ARN)
entries.
- `"maxResults"`: The maximum number of results returned by DescribeJobQueues in paginated
output. When this parameter is used, DescribeJobQueues only returns maxResults results in a
single page and a nextToken response element. The remaining results of the initial request
can be seen by sending another DescribeJobQueues request with the returned nextToken value.
This value can be between 1 and 100. If this parameter isn't used, then DescribeJobQueues
returns up to 100 results and a nextToken value if applicable.
- `"nextToken"`: The nextToken value returned from a previous paginated DescribeJobQueues
request where maxResults was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken
value. This value is null when there are no more results to return. Treat this token as an
opaque identifier that's only used to retrieve the next items in a list and not for other
programmatic purposes.
"""
function describe_job_queues(; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/describejobqueues";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_job_queues(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describejobqueues",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_jobs(jobs)
describe_jobs(jobs, params::Dict{String,<:Any})
Describes a list of Batch jobs.
# Arguments
- `jobs`: A list of up to 100 job IDs.
"""
function describe_jobs(jobs; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/describejobs",
Dict{String,Any}("jobs" => jobs);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_jobs(
jobs, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describejobs",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("jobs" => jobs), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scheduling_policies(arns)
describe_scheduling_policies(arns, params::Dict{String,<:Any})
Describes one or more of your scheduling policies.
# Arguments
- `arns`: A list of up to 100 scheduling policy Amazon Resource Name (ARN) entries.
"""
function describe_scheduling_policies(
arns; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describeschedulingpolicies",
Dict{String,Any}("arns" => arns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scheduling_policies(
arns, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/describeschedulingpolicies",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arns" => arns), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_job_queue_snapshot(job_queue)
get_job_queue_snapshot(job_queue, params::Dict{String,<:Any})
Provides a list of the first 100 RUNNABLE jobs associated to a single job queue.
# Arguments
- `job_queue`: The job queue’s name or full queue Amazon Resource Name (ARN).
"""
function get_job_queue_snapshot(jobQueue; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/getjobqueuesnapshot",
Dict{String,Any}("jobQueue" => jobQueue);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_job_queue_snapshot(
jobQueue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/getjobqueuesnapshot",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("jobQueue" => jobQueue), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_jobs()
list_jobs(params::Dict{String,<:Any})
Returns a list of Batch jobs. You must specify only one of the following items: A job
queue ID to return a list of jobs in that job queue A multi-node parallel job ID to
return a list of nodes for that job An array job ID to return a list of the children for
that job You can filter the results by job status with the jobStatus parameter. If you
don't specify a status, only RUNNING jobs are returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"arrayJobId"`: The job ID for an array job. Specifying an array job ID with this
parameter lists all child jobs from within the specified array.
- `"filters"`: The filter to apply to the query. Only one filter can be used at a time.
When the filter is used, jobStatus is ignored. The filter doesn't apply to child jobs in an
array or multi-node parallel (MNP) jobs. The results are sorted by the createdAt field,
with the most recent jobs being first. JOB_NAME The value of the filter is a
case-insensitive match for the job name. If the value ends with an asterisk (*), the filter
matches any job name that begins with the string before the '*'. This corresponds to the
jobName value. For example, test1 matches both Test1 and test1, and test1* matches both
test1 and Test10. When the JOB_NAME filter is used, the results are grouped by the job name
and version. JOB_DEFINITION The value for the filter is the name or Amazon Resource Name
(ARN) of the job definition. This corresponds to the jobDefinition value. The value is case
sensitive. When the value for the filter is the job definition name, the results include
all the jobs that used any revision of that job definition name. If the value ends with an
asterisk (*), the filter matches any job definition name that begins with the string before
the '*'. For example, jd1 matches only jd1, and jd1* matches both jd1 and jd1A. The version
of the job definition that's used doesn't affect the sort order. When the JOB_DEFINITION
filter is used and the ARN is used (which is in the form
arn:{Partition}:batch:{Region}:{Account}:job-definition/{JobDefinitionName}:{Revision}),
the results include jobs that used the specified revision of the job definition. Asterisk
(*) isn't supported when the ARN is used. BEFORE_CREATED_AT The value for the filter is
the time that's before the job was created. This corresponds to the createdAt value. The
value is a string representation of the number of milliseconds since 00:00:00 UTC
(midnight) on January 1, 1970. AFTER_CREATED_AT The value for the filter is the time
that's after the job was created. This corresponds to the createdAt value. The value is a
string representation of the number of milliseconds since 00:00:00 UTC (midnight) on
January 1, 1970.
- `"jobQueue"`: The name or full Amazon Resource Name (ARN) of the job queue used to list
jobs.
- `"jobStatus"`: The job status used to filter jobs in the specified queue. If the filters
parameter is specified, the jobStatus parameter is ignored and jobs with any status are
returned. If you don't specify a status, only RUNNING jobs are returned.
- `"maxResults"`: The maximum number of results returned by ListJobs in a paginated output.
When this parameter is used, ListJobs returns up to maxResults results in a single page and
a nextToken response element, if applicable. The remaining results of the initial request
can be seen by sending another ListJobs request with the returned nextToken value. The
following outlines key parameters and limitations: The minimum value is 1. When
--job-status is used, Batch returns up to 1000 values. When --filters is used, Batch
returns up to 100 values. If neither parameter is used, then ListJobs returns up to 1000
results (jobs that are in the RUNNING status) and a nextToken value, if applicable.
- `"multiNodeJobId"`: The job ID for a multi-node parallel job. Specifying a multi-node
parallel job ID with this parameter lists all nodes that are associated with the specified
job.
- `"nextToken"`: The nextToken value returned from a previous paginated ListJobs request
where maxResults was used and the results exceeded the value of that parameter. Pagination
continues from the end of the previous results that returned the nextToken value. This
value is null when there are no more results to return. Treat this token as an opaque
identifier that's only used to retrieve the next items in a list and not for other
programmatic purposes.
"""
function list_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST", "/v1/listjobs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/listjobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_scheduling_policies()
list_scheduling_policies(params::Dict{String,<:Any})
Returns a list of Batch scheduling policies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results that's returned by ListSchedulingPolicies
in paginated output. When this parameter is used, ListSchedulingPolicies only returns
maxResults results in a single page and a nextToken response element. You can see the
remaining results of the initial request by sending another ListSchedulingPolicies request
with the returned nextToken value. This value can be between 1 and 100. If this parameter
isn't used, ListSchedulingPolicies returns up to 100 results and a nextToken value if
applicable.
- `"nextToken"`: The nextToken value that's returned from a previous paginated
ListSchedulingPolicies request where maxResults was used and the results exceeded the value
of that parameter. Pagination continues from the end of the previous results that returned
the nextToken value. This value is null when there are no more results to return. Treat
this token as an opaque identifier that's only used to retrieve the next items in a list
and not for other programmatic purposes.
"""
function list_scheduling_policies(; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/listschedulingpolicies";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_scheduling_policies(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/listschedulingpolicies",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists the tags for an Batch resource. Batch resources that support tags are compute
environments, jobs, job definitions, job queues, and scheduling policies. ARNs for child
jobs of array and multi-node parallel (MNP) jobs aren't supported.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) that identifies the resource that tags are
listed for. Batch resources that support tags are compute environments, jobs, job
definitions, job queues, and scheduling policies. ARNs for child jobs of array and
multi-node parallel (MNP) jobs aren't supported.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"GET",
"/v1/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"GET",
"/v1/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_job_definition(job_definition_name, type)
register_job_definition(job_definition_name, type, params::Dict{String,<:Any})
Registers an Batch job definition.
# Arguments
- `job_definition_name`: The name of the job definition to register. It can be up to 128
letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and
underscores (_).
- `type`: The type of job definition. For more information about multi-node parallel jobs,
see Creating a multi-node parallel job definition in the Batch User Guide. If the value
is container, then one of the following is required: containerProperties, ecsProperties, or
eksProperties. If the value is multinode, then nodeProperties is required. If the job
is run on Fargate resources, then multinode isn't supported.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"containerProperties"`: An object with properties specific to Amazon ECS-based
single-node container-based jobs. If the job definition's type parameter is container, then
you must specify either containerProperties or nodeProperties. This must not be specified
for Amazon EKS-based job definitions. If the job runs on Fargate resources, then you must
not specify nodeProperties; use only containerProperties.
- `"ecsProperties"`: An object with properties that are specific to Amazon ECS-based jobs.
This must not be specified for Amazon EKS-based job definitions.
- `"eksProperties"`: An object with properties that are specific to Amazon EKS-based jobs.
This must not be specified for Amazon ECS based job definitions.
- `"nodeProperties"`: An object with properties specific to multi-node parallel jobs. If
you specify node properties for a job, it becomes a multi-node parallel job. For more
information, see Multi-node Parallel Jobs in the Batch User Guide. If the job runs on
Fargate resources, then you must not specify nodeProperties; use containerProperties
instead. If the job runs on Amazon EKS resources, then you must not specify
nodeProperties.
- `"parameters"`: Default parameter substitution placeholders to set in the job definition.
Parameters are specified as a key-value pair mapping. Parameters in a SubmitJob request
override any corresponding parameter defaults from the job definition.
- `"platformCapabilities"`: The platform capabilities required by the job definition. If no
value is specified, it defaults to EC2. To run the job on Fargate resources, specify
FARGATE. If the job runs on Amazon EKS resources, then you must not specify
platformCapabilities.
- `"propagateTags"`: Specifies whether to propagate the tags from the job or job definition
to the corresponding Amazon ECS task. If no value is specified, the tags are not
propagated. Tags can only be propagated to the tasks during task creation. For tags with
the same name, job tags are given priority over job definitions tags. If the total number
of combined tags from the job and job definition is over 50, the job is moved to the FAILED
state. If the job runs on Amazon EKS resources, then you must not specify propagateTags.
- `"retryStrategy"`: The retry strategy to use for failed jobs that are submitted with this
job definition. Any retry strategy that's specified during a SubmitJob operation overrides
the retry strategy defined here. If a job is terminated due to a timeout, it isn't retried.
- `"schedulingPriority"`: The scheduling priority for jobs that are submitted with this job
definition. This only affects jobs in job queues with a fair share policy. Jobs with a
higher scheduling priority are scheduled before jobs with a lower scheduling priority. The
minimum supported value is 0 and the maximum supported value is 9999.
- `"tags"`: The tags that you apply to the job definition to help you categorize and
organize your resources. Each tag consists of a key and an optional value. For more
information, see Tagging Amazon Web Services Resources in Batch User Guide.
- `"timeout"`: The timeout configuration for jobs that are submitted with this job
definition, after which Batch terminates your jobs if they have not finished. If a job is
terminated due to a timeout, it isn't retried. The minimum value for the timeout is 60
seconds. Any timeout configuration that's specified during a SubmitJob operation overrides
the timeout configuration defined here. For more information, see Job Timeouts in the Batch
User Guide.
"""
function register_job_definition(
jobDefinitionName, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/registerjobdefinition",
Dict{String,Any}("jobDefinitionName" => jobDefinitionName, "type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_job_definition(
jobDefinitionName,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/registerjobdefinition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("jobDefinitionName" => jobDefinitionName, "type" => type),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
submit_job(job_definition, job_name, job_queue)
submit_job(job_definition, job_name, job_queue, params::Dict{String,<:Any})
Submits an Batch job from a job definition. Parameters that are specified during SubmitJob
override parameters defined in the job definition. vCPU and memory requirements that are
specified in the resourceRequirements objects in the job definition are the exception. They
can't be overridden this way using the memory and vcpus parameters. Rather, you must
specify updates to job definition parameters in a resourceRequirements object that's
included in the containerOverrides parameter. Job queues with a scheduling policy are
limited to 500 active fair share identifiers at a time. Jobs that run on Fargate
resources can't be guaranteed to run for more than 14 days. This is because, after 14 days,
Fargate resources might become unavailable and job might be terminated.
# Arguments
- `job_definition`: The job definition used by this job. This value can be one of
definition-name, definition-name:revision, or the Amazon Resource Name (ARN) for the job
definition, with or without the revision
(arn:aws:batch:region:account:job-definition/definition-name:revision , or
arn:aws:batch:region:account:job-definition/definition-name ). If the revision is not
specified, then the latest active revision is used.
- `job_name`: The name of the job. It can be up to 128 letters long. The first character
must be alphanumeric, can contain uppercase and lowercase letters, numbers, hyphens (-),
and underscores (_).
- `job_queue`: The job queue where the job is submitted. You can specify either the name or
the Amazon Resource Name (ARN) of the queue.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"arrayProperties"`: The array properties for the submitted job, such as the size of the
array. The array size can be between 2 and 10,000. If you specify array properties for a
job, it becomes an array job. For more information, see Array Jobs in the Batch User Guide.
- `"containerOverrides"`: An object with properties that override the defaults for the job
definition that specify the name of a container in the specified job definition and the
overrides it should receive. You can override the default command for a container, which is
specified in the job definition or the Docker image, with a command override. You can also
override existing environment variables on a container or add new environment variables to
it with an environment override.
- `"dependsOn"`: A list of dependencies for the job. A job can depend upon a maximum of 20
jobs. You can specify a SEQUENTIAL type dependency without specifying a job ID for array
jobs so that each child array job completes sequentially, starting at index 0. You can also
specify an N_TO_N type dependency with a job ID for array jobs. In that case, each index
child of this job must wait for the corresponding index child of each dependency to
complete before it can begin.
- `"ecsPropertiesOverride"`: An object, with properties that override defaults for the job
definition, can only be specified for jobs that are run on Amazon ECS resources.
- `"eksPropertiesOverride"`: An object, with properties that override defaults for the job
definition, can only be specified for jobs that are run on Amazon EKS resources.
- `"nodeOverrides"`: A list of node overrides in JSON format that specify the node range to
target and the container overrides for that node range. This parameter isn't applicable to
jobs that are running on Fargate resources; use containerOverrides instead.
- `"parameters"`: Additional parameters passed to the job that replace parameter
substitution placeholders that are set in the job definition. Parameters are specified as a
key and value pair mapping. Parameters in a SubmitJob request override any corresponding
parameter defaults from the job definition.
- `"propagateTags"`: Specifies whether to propagate the tags from the job or job definition
to the corresponding Amazon ECS task. If no value is specified, the tags aren't propagated.
Tags can only be propagated to the tasks during task creation. For tags with the same name,
job tags are given priority over job definitions tags. If the total number of combined tags
from the job and job definition is over 50, the job is moved to the FAILED state. When
specified, this overrides the tag propagation setting in the job definition.
- `"retryStrategy"`: The retry strategy to use for failed jobs from this SubmitJob
operation. When a retry strategy is specified here, it overrides the retry strategy defined
in the job definition.
- `"schedulingPriorityOverride"`: The scheduling priority for the job. This only affects
jobs in job queues with a fair share policy. Jobs with a higher scheduling priority are
scheduled before jobs with a lower scheduling priority. This overrides any scheduling
priority in the job definition and works only within a single share identifier. The minimum
supported value is 0 and the maximum supported value is 9999.
- `"shareIdentifier"`: The share identifier for the job. Don't specify this parameter if
the job queue doesn't have a scheduling policy. If the job queue has a scheduling policy,
then this parameter must be specified. This string is limited to 255 alphanumeric
characters, and can be followed by an asterisk (*).
- `"tags"`: The tags that you apply to the job request to help you categorize and organize
your resources. Each tag consists of a key and an optional value. For more information, see
Tagging Amazon Web Services Resources in Amazon Web Services General Reference.
- `"timeout"`: The timeout configuration for this SubmitJob operation. You can specify a
timeout duration after which Batch terminates your jobs if they haven't finished. If a job
is terminated due to a timeout, it isn't retried. The minimum value for the timeout is 60
seconds. This configuration overrides any timeout configuration specified in the job
definition. For array jobs, child jobs have the same timeout configuration as the parent
job. For more information, see Job Timeouts in the Amazon Elastic Container Service
Developer Guide.
"""
function submit_job(
jobDefinition, jobName, jobQueue; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/submitjob",
Dict{String,Any}(
"jobDefinition" => jobDefinition, "jobName" => jobName, "jobQueue" => jobQueue
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function submit_job(
jobDefinition,
jobName,
jobQueue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/submitjob",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"jobDefinition" => jobDefinition,
"jobName" => jobName,
"jobQueue" => jobQueue,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associates the specified tags to a resource with the specified resourceArn. If existing
tags on a resource aren't specified in the request parameters, they aren't changed. When a
resource is deleted, the tags that are associated with that resource are deleted as well.
Batch resources that support tags are compute environments, jobs, job definitions, job
queues, and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP)
jobs aren't supported.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that tags are added to.
Batch resources that support tags are compute environments, jobs, job definitions, job
queues, and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP)
jobs aren't supported.
- `tags`: The tags that you apply to the resource to help you categorize and organize your
resources. Each tag consists of a key and an optional value. For more information, see
Tagging Amazon Web Services Resources in Amazon Web Services General Reference.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
terminate_job(job_id, reason)
terminate_job(job_id, reason, params::Dict{String,<:Any})
Terminates a job in a job queue. Jobs that are in the STARTING or RUNNING state are
terminated, which causes them to transition to FAILED. Jobs that have not progressed to the
STARTING state are cancelled.
# Arguments
- `job_id`: The Batch job ID of the job to terminate.
- `reason`: A message to attach to the job that explains the reason for canceling it. This
message is returned by future DescribeJobs operations on the job. This message is also
recorded in the Batch activity logs.
"""
function terminate_job(jobId, reason; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/terminatejob",
Dict{String,Any}("jobId" => jobId, "reason" => reason);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function terminate_job(
jobId,
reason,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/terminatejob",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("jobId" => jobId, "reason" => reason), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Deletes specified tags from an Batch resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource from which to delete tags.
Batch resources that support tags are compute environments, jobs, job definitions, job
queues, and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP)
jobs aren't supported.
- `tag_keys`: The keys of the tags to be removed.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"DELETE",
"/v1/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"DELETE",
"/v1/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_compute_environment(compute_environment)
update_compute_environment(compute_environment, params::Dict{String,<:Any})
Updates an Batch compute environment.
# Arguments
- `compute_environment`: The name or full Amazon Resource Name (ARN) of the compute
environment to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computeResources"`: Details of the compute resources managed by the compute
environment. Required for a managed compute environment. For more information, see Compute
Environments in the Batch User Guide.
- `"serviceRole"`: The full Amazon Resource Name (ARN) of the IAM role that allows Batch to
make calls to other Amazon Web Services services on your behalf. For more information, see
Batch service IAM role in the Batch User Guide. If the compute environment has a
service-linked role, it can't be changed to use a regular IAM role. Likewise, if the
compute environment has a regular IAM role, it can't be changed to use a service-linked
role. To update the parameters for the compute environment that require an infrastructure
update to change, the AWSServiceRoleForBatch service-linked role must be used. For more
information, see Updating compute environments in the Batch User Guide. If your specified
role has a path other than /, then you must either specify the full role ARN (recommended)
or prefix the role name with the path. Depending on how you created your Batch service
role, its ARN might contain the service-role path prefix. When you only specify the name of
the service role, Batch assumes that your ARN doesn't use the service-role path prefix.
Because of this, we recommend that you specify the full ARN of your service role when you
create compute environments.
- `"state"`: The state of the compute environment. Compute environments in the ENABLED
state can accept jobs from a queue and scale in or out automatically based on the workload
demand of its associated queues. If the state is ENABLED, then the Batch scheduler can
attempt to place jobs from an associated job queue on the compute resources within the
environment. If the compute environment is managed, then it can scale its instances out or
in automatically, based on the job queue demand. If the state is DISABLED, then the Batch
scheduler doesn't attempt to place jobs within the environment. Jobs in a STARTING or
RUNNING state continue to progress normally. Managed compute environments in the DISABLED
state don't scale out. Compute environments in a DISABLED state may continue to incur
billing charges. To prevent additional charges, turn off and then delete the compute
environment. For more information, see State in the Batch User Guide. When an instance is
idle, the instance scales down to the minvCpus value. However, the instance size doesn't
change. For example, consider a c5.8xlarge instance with a minvCpus value of 4 and a
desiredvCpus value of 36. This instance doesn't scale down to a c5.large instance.
- `"unmanagedvCpus"`: The maximum number of vCPUs expected to be used for an unmanaged
compute environment. Don't specify this parameter for a managed compute environment. This
parameter is only used for fair share scheduling to reserve vCPU capacity for new share
identifiers. If this parameter isn't provided for a fair share job queue, no vCPU capacity
is reserved.
- `"updatePolicy"`: Specifies the updated infrastructure update policy for the compute
environment. For more information about infrastructure updates, see Updating compute
environments in the Batch User Guide.
"""
function update_compute_environment(
computeEnvironment; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/updatecomputeenvironment",
Dict{String,Any}("computeEnvironment" => computeEnvironment);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_compute_environment(
computeEnvironment,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/updatecomputeenvironment",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("computeEnvironment" => computeEnvironment), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_job_queue(job_queue)
update_job_queue(job_queue, params::Dict{String,<:Any})
Updates a job queue.
# Arguments
- `job_queue`: The name or the Amazon Resource Name (ARN) of the job queue.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computeEnvironmentOrder"`: Details the set of compute environments mapped to a job
queue and their order relative to each other. This is one of the parameters used by the job
scheduler to determine which compute environment runs a given job. Compute environments
must be in the VALID state before you can associate them with a job queue. All of the
compute environments must be either EC2 (EC2 or SPOT) or Fargate (FARGATE or FARGATE_SPOT).
EC2 and Fargate compute environments can't be mixed. All compute environments that are
associated with a job queue must share the same architecture. Batch doesn't support mixing
compute environment architecture types in a single job queue.
- `"jobStateTimeLimitActions"`: The set of actions that Batch perform on jobs that remain
at the head of the job queue in the specified state longer than specified times. Batch will
perform each action after maxTimeSeconds has passed.
- `"priority"`: The priority of the job queue. Job queues with a higher priority (or a
higher integer value for the priority parameter) are evaluated first when associated with
the same compute environment. Priority is determined in descending order. For example, a
job queue with a priority value of 10 is given scheduling preference over a job queue with
a priority value of 1. All of the compute environments must be either EC2 (EC2 or SPOT) or
Fargate (FARGATE or FARGATE_SPOT). EC2 and Fargate compute environments can't be mixed.
- `"schedulingPolicyArn"`: Amazon Resource Name (ARN) of the fair share scheduling policy.
Once a job queue is created, the fair share scheduling policy can be replaced but not
removed. The format is aws:Partition:batch:Region:Account:scheduling-policy/Name . For
example, aws:aws:batch:us-west-2:123456789012:scheduling-policy/MySchedulingPolicy.
- `"state"`: Describes the queue's ability to accept new jobs. If the job queue state is
ENABLED, it can accept jobs. If the job queue state is DISABLED, new jobs can't be added to
the queue, but jobs already in the queue can finish.
"""
function update_job_queue(jobQueue; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/updatejobqueue",
Dict{String,Any}("jobQueue" => jobQueue);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_job_queue(
jobQueue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return batch(
"POST",
"/v1/updatejobqueue",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("jobQueue" => jobQueue), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_scheduling_policy(arn)
update_scheduling_policy(arn, params::Dict{String,<:Any})
Updates a scheduling policy.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the scheduling policy to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"fairsharePolicy"`: The fair share policy.
"""
function update_scheduling_policy(arn; aws_config::AbstractAWSConfig=global_aws_config())
return batch(
"POST",
"/v1/updateschedulingpolicy",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_scheduling_policy(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return batch(
"POST",
"/v1/updateschedulingpolicy",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 14220 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: bcm_data_exports
using AWS.Compat
using AWS.UUIDs
"""
create_export(export)
create_export(export, params::Dict{String,<:Any})
Creates a data export and specifies the data query, the delivery preference, and any
optional resource tags. A DataQuery consists of both a QueryStatement and
TableConfigurations. The QueryStatement is an SQL statement. Data Exports only supports a
limited subset of the SQL syntax. For more information on the SQL syntax that is supported,
see Data query. To view the available tables and columns, see the Data Exports table
dictionary. The TableConfigurations is a collection of specified TableProperties for the
table being queried in the QueryStatement. TableProperties are additional configurations
you can provide to change the data and schema of a table. Each table can have different
TableProperties. However, tables are not required to have any TableProperties. Each table
property has a default value that it assumes if not specified. For more information on
table configurations, see Data query. To view the table properties available for each
table, see the Data Exports table dictionary or use the ListTables API to get a response of
all tables and their available properties.
# Arguments
- `export`: The details of the export, including data query, name, description, and
destination configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ResourceTags"`: An optional list of tags to associate with the specified export. Each
tag consists of a key and a value, and each key must be unique for the resource.
"""
function create_export(Export; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"CreateExport",
Dict{String,Any}("Export" => Export);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_export(
Export, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"CreateExport",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Export" => Export), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_export(export_arn)
delete_export(export_arn, params::Dict{String,<:Any})
Deletes an existing data export.
# Arguments
- `export_arn`: The Amazon Resource Name (ARN) for this export.
"""
function delete_export(ExportArn; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"DeleteExport",
Dict{String,Any}("ExportArn" => ExportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_export(
ExportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"DeleteExport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExportArn" => ExportArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_execution(execution_id, export_arn)
get_execution(execution_id, export_arn, params::Dict{String,<:Any})
Exports data based on the source data update.
# Arguments
- `execution_id`: The ID for this specific execution.
- `export_arn`: The Amazon Resource Name (ARN) of the Export object that generated this
specific execution.
"""
function get_execution(
ExecutionId, ExportArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"GetExecution",
Dict{String,Any}("ExecutionId" => ExecutionId, "ExportArn" => ExportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_execution(
ExecutionId,
ExportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"GetExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ExecutionId" => ExecutionId, "ExportArn" => ExportArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_export(export_arn)
get_export(export_arn, params::Dict{String,<:Any})
Views the definition of an existing data export.
# Arguments
- `export_arn`: The Amazon Resource Name (ARN) for this export.
"""
function get_export(ExportArn; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"GetExport",
Dict{String,Any}("ExportArn" => ExportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_export(
ExportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"GetExport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExportArn" => ExportArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_table(table_name)
get_table(table_name, params::Dict{String,<:Any})
Returns the metadata for the specified table and table properties. This includes the list
of columns in the table schema, their data types, and column descriptions.
# Arguments
- `table_name`: The name of the table.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"TableProperties"`: TableProperties are additional configurations you can provide to
change the data and schema of a table. Each table can have different TableProperties.
Tables are not required to have any TableProperties. Each table property has a default
value that it assumes if not specified.
"""
function get_table(TableName; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"GetTable",
Dict{String,Any}("TableName" => TableName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_table(
TableName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"GetTable",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TableName" => TableName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_executions(export_arn)
list_executions(export_arn, params::Dict{String,<:Any})
Lists the historical executions for the export.
# Arguments
- `export_arn`: The Amazon Resource Name (ARN) for this export.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of objects that are returned for the request.
- `"NextToken"`: The token to retrieve the next set of results.
"""
function list_executions(ExportArn; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"ListExecutions",
Dict{String,Any}("ExportArn" => ExportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_executions(
ExportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"ListExecutions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExportArn" => ExportArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_exports()
list_exports(params::Dict{String,<:Any})
Lists all data export definitions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of objects that are returned for the request.
- `"NextToken"`: The token to retrieve the next set of results.
"""
function list_exports(; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"ListExports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_exports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"ListExports", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tables()
list_tables(params::Dict{String,<:Any})
Lists all available tables in data exports.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of objects that are returned for the request.
- `"NextToken"`: The token to retrieve the next set of results.
"""
function list_tables(; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"ListTables"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_tables(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"ListTables", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
List tags associated with an existing data export.
# Arguments
- `resource_arn`: The unique identifier for the resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of objects that are returned for the request.
- `"NextToken"`: The token to retrieve the next set of results.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, resource_tags)
tag_resource(resource_arn, resource_tags, params::Dict{String,<:Any})
Adds tags for an existing data export definition.
# Arguments
- `resource_arn`: The unique identifier for the resource.
- `resource_tags`: The tags to associate with the resource. Each tag consists of a key and
a value, and each key must be unique for the resource.
"""
function tag_resource(
ResourceArn, ResourceTags; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"TagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "ResourceTags" => ResourceTags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
ResourceTags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceArn" => ResourceArn, "ResourceTags" => ResourceTags
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, resource_tag_keys)
untag_resource(resource_arn, resource_tag_keys, params::Dict{String,<:Any})
Deletes tags associated with an existing data export definition.
# Arguments
- `resource_arn`: The unique identifier for the resource.
- `resource_tag_keys`: The tag keys that are associated with the resource ARN.
"""
function untag_resource(
ResourceArn, ResourceTagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return bcm_data_exports(
"UntagResource",
Dict{String,Any}(
"ResourceArn" => ResourceArn, "ResourceTagKeys" => ResourceTagKeys
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
ResourceTagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceArn" => ResourceArn, "ResourceTagKeys" => ResourceTagKeys
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_export(export, export_arn)
update_export(export, export_arn, params::Dict{String,<:Any})
Updates an existing data export by overwriting all export parameters. All export parameters
must be provided in the UpdateExport request.
# Arguments
- `export`: The name and query details for the export.
- `export_arn`: The Amazon Resource Name (ARN) for this export.
"""
function update_export(Export, ExportArn; aws_config::AbstractAWSConfig=global_aws_config())
return bcm_data_exports(
"UpdateExport",
Dict{String,Any}("Export" => Export, "ExportArn" => ExportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_export(
Export,
ExportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bcm_data_exports(
"UpdateExport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Export" => Export, "ExportArn" => ExportArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 50214 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: bedrock
using AWS.Compat
using AWS.UUIDs
"""
create_evaluation_job(evaluation_config, inference_config, job_name, output_data_config, role_arn)
create_evaluation_job(evaluation_config, inference_config, job_name, output_data_config, role_arn, params::Dict{String,<:Any})
API operation for creating and managing Amazon Bedrock automatic model evaluation jobs and
model evaluation jobs that use human workers. To learn more about the requirements for
creating a model evaluation job see, Model evaluations.
# Arguments
- `evaluation_config`: Specifies whether the model evaluation job is automatic or uses
human worker.
- `inference_config`: Specify the models you want to use in your model evaluation job.
Automatic model evaluation jobs support a single model, and model evaluation job that use
human workers support two models.
- `job_name`: The name of the model evaluation job. Model evaluation job names must unique
with your AWS account, and your account's AWS region.
- `output_data_config`: An object that defines where the results of model evaluation job
will be saved in Amazon S3.
- `role_arn`: The Amazon Resource Name (ARN) of an IAM service role that Amazon Bedrock can
assume to perform tasks on your behalf. The service role must have Amazon Bedrock as the
service principal, and provide access to any Amazon S3 buckets specified in the
EvaluationConfig object. To pass this role to Amazon Bedrock, the caller of this API must
have the iam:PassRole permission. To learn more about the required permissions, see
Required permissions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, case-sensitive identifier to ensure that the API
request completes no more than one time. If this token matches a previous request, Amazon
Bedrock ignores the request, but does not return an error. For more information, see
Ensuring idempotency.
- `"customerEncryptionKeyId"`: Specify your customer managed key ARN that will be used to
encrypt your model evaluation job.
- `"jobDescription"`: A description of the model evaluation job.
- `"jobTags"`: Tags to attach to the model evaluation job.
"""
function create_evaluation_job(
evaluationConfig,
inferenceConfig,
jobName,
outputDataConfig,
roleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/evaluation-jobs",
Dict{String,Any}(
"evaluationConfig" => evaluationConfig,
"inferenceConfig" => inferenceConfig,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_evaluation_job(
evaluationConfig,
inferenceConfig,
jobName,
outputDataConfig,
roleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/evaluation-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"evaluationConfig" => evaluationConfig,
"inferenceConfig" => inferenceConfig,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_guardrail(blocked_input_messaging, blocked_outputs_messaging, name)
create_guardrail(blocked_input_messaging, blocked_outputs_messaging, name, params::Dict{String,<:Any})
Creates a guardrail to block topics and to filter out harmful content. Specify a name and
optional description. Specify messages for when the guardrail successfully blocks a
prompt or a model response in the blockedInputMessaging and blockedOutputsMessaging fields.
Specify topics for the guardrail to deny in the topicPolicyConfig object. Each
GuardrailTopicConfig object in the topicsConfig list pertains to one topic. Give a name
and description so that the guardrail can properly identify the topic. Specify DENY in
the type field. (Optional) Provide up to five prompts that you would categorize as
belonging to the topic in the examples list. Specify filter strengths for the harmful
categories defined in Amazon Bedrock in the contentPolicyConfig object. Each
GuardrailContentFilterConfig object in the filtersConfig list pertains to a harmful
category. For more information, see Content filters. For more information about the fields
in a content filter, see GuardrailContentFilterConfig. Specify the category in the type
field. Specify the strength of the filter for prompts in the inputStrength field and for
model responses in the strength field of the GuardrailContentFilterConfig. (Optional)
For security, include the ARN of a KMS key in the kmsKeyId field. (Optional) Attach any
tags to the guardrail in the tags object. For more information, see Tag resources.
# Arguments
- `blocked_input_messaging`: The message to return when the guardrail blocks a prompt.
- `blocked_outputs_messaging`: The message to return when the guardrail blocks a model
response.
- `name`: The name to give the guardrail.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, case-sensitive identifier to ensure that the API
request completes no more than once. If this token matches a previous request, Amazon
Bedrock ignores the request, but does not return an error. For more information, see
Ensuring idempotency in the Amazon S3 User Guide.
- `"contentPolicyConfig"`: The content filter policies to configure for the guardrail.
- `"description"`: A description of the guardrail.
- `"kmsKeyId"`: The ARN of the KMS key that you use to encrypt the guardrail.
- `"sensitiveInformationPolicyConfig"`: The sensitive information policy to configure for
the guardrail.
- `"tags"`: The tags that you want to attach to the guardrail.
- `"topicPolicyConfig"`: The topic policies to configure for the guardrail.
- `"wordPolicyConfig"`: The word policy you configure for the guardrail.
"""
function create_guardrail(
blockedInputMessaging,
blockedOutputsMessaging,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/guardrails",
Dict{String,Any}(
"blockedInputMessaging" => blockedInputMessaging,
"blockedOutputsMessaging" => blockedOutputsMessaging,
"name" => name,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_guardrail(
blockedInputMessaging,
blockedOutputsMessaging,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/guardrails",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"blockedInputMessaging" => blockedInputMessaging,
"blockedOutputsMessaging" => blockedOutputsMessaging,
"name" => name,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_guardrail_version(guardrail_identifier)
create_guardrail_version(guardrail_identifier, params::Dict{String,<:Any})
Creates a version of the guardrail. Use this API to create a snapshot of the guardrail when
you are satisfied with a configuration, or to compare the configuration with another
version.
# Arguments
- `guardrail_identifier`: The unique identifier of the guardrail.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, case-sensitive identifier to ensure that the API
request completes no more than once. If this token matches a previous request, Amazon
Bedrock ignores the request, but does not return an error. For more information, see
Ensuring idempotency in the Amazon S3 User Guide.
- `"description"`: A description of the guardrail version.
"""
function create_guardrail_version(
guardrailIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"POST",
"/guardrails/$(guardrailIdentifier)",
Dict{String,Any}("clientRequestToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_guardrail_version(
guardrailIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/guardrails/$(guardrailIdentifier)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("clientRequestToken" => string(uuid4())), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_model_customization_job(base_model_identifier, custom_model_name, hyper_parameters, job_name, output_data_config, role_arn, training_data_config)
create_model_customization_job(base_model_identifier, custom_model_name, hyper_parameters, job_name, output_data_config, role_arn, training_data_config, params::Dict{String,<:Any})
Creates a fine-tuning job to customize a base model. You specify the base foundation model
and the location of the training data. After the model-customization job completes
successfully, your custom model resource will be ready to use. Amazon Bedrock returns
validation loss metrics and output generations after the job completes. For information on
the format of training and validation data, see Prepare the datasets. Model-customization
jobs are asynchronous and the completion time depends on the base model and the
training/validation data size. To monitor a job, use the GetModelCustomizationJob operation
to retrieve the job status. For more information, see Custom models in the Amazon Bedrock
User Guide.
# Arguments
- `base_model_identifier`: Name of the base model.
- `custom_model_name`: A name for the resulting custom model.
- `hyper_parameters`: Parameters related to tuning the model. For details on the format for
different models, see Custom model hyperparameters.
- `job_name`: A name for the fine-tuning job.
- `output_data_config`: S3 location for the output data.
- `role_arn`: The Amazon Resource Name (ARN) of an IAM service role that Amazon Bedrock can
assume to perform tasks on your behalf. For example, during model training, Amazon Bedrock
needs your permission to read input data from an S3 bucket, write model artifacts to an S3
bucket. To pass this role to Amazon Bedrock, the caller of this API must have the
iam:PassRole permission.
- `training_data_config`: Information about the training dataset.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, case-sensitive identifier to ensure that the API
request completes no more than one time. If this token matches a previous request, Amazon
Bedrock ignores the request, but does not return an error. For more information, see
Ensuring idempotency.
- `"customModelKmsKeyId"`: The custom model is encrypted at rest using this key.
- `"customModelTags"`: Tags to attach to the resulting custom model.
- `"customizationType"`: The customization type.
- `"jobTags"`: Tags to attach to the job.
- `"validationDataConfig"`: Information about the validation dataset.
- `"vpcConfig"`: VPC configuration (optional). Configuration parameters for the private
Virtual Private Cloud (VPC) that contains the resources you are using for this job.
"""
function create_model_customization_job(
baseModelIdentifier,
customModelName,
hyperParameters,
jobName,
outputDataConfig,
roleArn,
trainingDataConfig;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/model-customization-jobs",
Dict{String,Any}(
"baseModelIdentifier" => baseModelIdentifier,
"customModelName" => customModelName,
"hyperParameters" => hyperParameters,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
"trainingDataConfig" => trainingDataConfig,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_model_customization_job(
baseModelIdentifier,
customModelName,
hyperParameters,
jobName,
outputDataConfig,
roleArn,
trainingDataConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/model-customization-jobs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"baseModelIdentifier" => baseModelIdentifier,
"customModelName" => customModelName,
"hyperParameters" => hyperParameters,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
"trainingDataConfig" => trainingDataConfig,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_provisioned_model_throughput(model_id, model_units, provisioned_model_name)
create_provisioned_model_throughput(model_id, model_units, provisioned_model_name, params::Dict{String,<:Any})
Creates dedicated throughput for a base or custom model with the model units and for the
duration that you specify. For pricing details, see Amazon Bedrock Pricing. For more
information, see Provisioned Throughput in the Amazon Bedrock User Guide.
# Arguments
- `model_id`: The Amazon Resource Name (ARN) or name of the model to associate with this
Provisioned Throughput. For a list of models for which you can purchase Provisioned
Throughput, see Amazon Bedrock model IDs for purchasing Provisioned Throughput in the
Amazon Bedrock User Guide.
- `model_units`: Number of model units to allocate. A model unit delivers a specific
throughput level for the specified model. The throughput level of a model unit specifies
the total number of input and output tokens that it can process and generate within a span
of one minute. By default, your account has no model units for purchasing Provisioned
Throughputs with commitment. You must first visit the Amazon Web Services support center to
request MUs. For model unit quotas, see Provisioned Throughput quotas in the Amazon Bedrock
User Guide. For more information about what an MU specifies, contact your Amazon Web
Services account manager.
- `provisioned_model_name`: The name for this Provisioned Throughput.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, case-sensitive identifier to ensure that the API
request completes no more than one time. If this token matches a previous request, Amazon
Bedrock ignores the request, but does not return an error. For more information, see
Ensuring idempotency in the Amazon S3 User Guide.
- `"commitmentDuration"`: The commitment duration requested for the Provisioned Throughput.
Billing occurs hourly and is discounted for longer commitment terms. To request a no-commit
Provisioned Throughput, omit this field. Custom models support all levels of commitment. To
see which base models support no commitment, see Supported regions and models for
Provisioned Throughput in the Amazon Bedrock User Guide
- `"tags"`: Tags to associate with this Provisioned Throughput.
"""
function create_provisioned_model_throughput(
modelId,
modelUnits,
provisionedModelName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/provisioned-model-throughput",
Dict{String,Any}(
"modelId" => modelId,
"modelUnits" => modelUnits,
"provisionedModelName" => provisionedModelName,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_provisioned_model_throughput(
modelId,
modelUnits,
provisionedModelName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/provisioned-model-throughput",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"modelId" => modelId,
"modelUnits" => modelUnits,
"provisionedModelName" => provisionedModelName,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_custom_model(model_identifier)
delete_custom_model(model_identifier, params::Dict{String,<:Any})
Deletes a custom model that you created earlier. For more information, see Custom models in
the Amazon Bedrock User Guide.
# Arguments
- `model_identifier`: Name of the model to delete.
"""
function delete_custom_model(
modelIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"DELETE",
"/custom-models/$(modelIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_custom_model(
modelIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"DELETE",
"/custom-models/$(modelIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_guardrail(guardrail_identifier)
delete_guardrail(guardrail_identifier, params::Dict{String,<:Any})
Deletes a guardrail. To delete a guardrail, only specify the ARN of the guardrail in the
guardrailIdentifier field. If you delete a guardrail, all of its versions will be deleted.
To delete a version of a guardrail, specify the ARN of the guardrail in the
guardrailIdentifier field and the version in the guardrailVersion field.
# Arguments
- `guardrail_identifier`: The unique identifier of the guardrail.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"guardrailVersion"`: The version of the guardrail.
"""
function delete_guardrail(
guardrailIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"DELETE",
"/guardrails/$(guardrailIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_guardrail(
guardrailIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"DELETE",
"/guardrails/$(guardrailIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_model_invocation_logging_configuration()
delete_model_invocation_logging_configuration(params::Dict{String,<:Any})
Delete the invocation logging.
"""
function delete_model_invocation_logging_configuration(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"DELETE",
"/logging/modelinvocations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_model_invocation_logging_configuration(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"DELETE",
"/logging/modelinvocations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_provisioned_model_throughput(provisioned_model_id)
delete_provisioned_model_throughput(provisioned_model_id, params::Dict{String,<:Any})
Deletes a Provisioned Throughput. You can't delete a Provisioned Throughput before the
commitment term is over. For more information, see Provisioned Throughput in the Amazon
Bedrock User Guide.
# Arguments
- `provisioned_model_id`: The Amazon Resource Name (ARN) or name of the Provisioned
Throughput.
"""
function delete_provisioned_model_throughput(
provisionedModelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"DELETE",
"/provisioned-model-throughput/$(provisionedModelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_provisioned_model_throughput(
provisionedModelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"DELETE",
"/provisioned-model-throughput/$(provisionedModelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_custom_model(model_identifier)
get_custom_model(model_identifier, params::Dict{String,<:Any})
Get the properties associated with a Amazon Bedrock custom model that you have created.For
more information, see Custom models in the Amazon Bedrock User Guide.
# Arguments
- `model_identifier`: Name or Amazon Resource Name (ARN) of the custom model.
"""
function get_custom_model(
modelIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/custom-models/$(modelIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_custom_model(
modelIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/custom-models/$(modelIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_evaluation_job(job_identifier)
get_evaluation_job(job_identifier, params::Dict{String,<:Any})
Retrieves the properties associated with a model evaluation job, including the status of
the job. For more information, see Model evaluations.
# Arguments
- `job_identifier`: The Amazon Resource Name (ARN) of the model evaluation job.
"""
function get_evaluation_job(
jobIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/evaluation-jobs/$(jobIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_evaluation_job(
jobIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/evaluation-jobs/$(jobIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_foundation_model(model_identifier)
get_foundation_model(model_identifier, params::Dict{String,<:Any})
Get details about a Amazon Bedrock foundation model.
# Arguments
- `model_identifier`: The model identifier.
"""
function get_foundation_model(
modelIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/foundation-models/$(modelIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_foundation_model(
modelIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/foundation-models/$(modelIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_guardrail(guardrail_identifier)
get_guardrail(guardrail_identifier, params::Dict{String,<:Any})
Gets details about a guardrail. If you don't specify a version, the response returns
details for the DRAFT version.
# Arguments
- `guardrail_identifier`: The unique identifier of the guardrail for which to get details.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"guardrailVersion"`: The version of the guardrail for which to get details. If you don't
specify a version, the response returns details for the DRAFT version.
"""
function get_guardrail(
guardrailIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/guardrails/$(guardrailIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_guardrail(
guardrailIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/guardrails/$(guardrailIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model_customization_job(job_identifier)
get_model_customization_job(job_identifier, params::Dict{String,<:Any})
Retrieves the properties associated with a model-customization job, including the status of
the job. For more information, see Custom models in the Amazon Bedrock User Guide.
# Arguments
- `job_identifier`: Identifier for the customization job.
"""
function get_model_customization_job(
jobIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/model-customization-jobs/$(jobIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model_customization_job(
jobIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/model-customization-jobs/$(jobIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_model_invocation_logging_configuration()
get_model_invocation_logging_configuration(params::Dict{String,<:Any})
Get the current configuration values for model invocation logging.
"""
function get_model_invocation_logging_configuration(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/logging/modelinvocations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_model_invocation_logging_configuration(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/logging/modelinvocations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_provisioned_model_throughput(provisioned_model_id)
get_provisioned_model_throughput(provisioned_model_id, params::Dict{String,<:Any})
Returns details for a Provisioned Throughput. For more information, see Provisioned
Throughput in the Amazon Bedrock User Guide.
# Arguments
- `provisioned_model_id`: The Amazon Resource Name (ARN) or name of the Provisioned
Throughput.
"""
function get_provisioned_model_throughput(
provisionedModelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/provisioned-model-throughput/$(provisionedModelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_provisioned_model_throughput(
provisionedModelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"GET",
"/provisioned-model-throughput/$(provisionedModelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_custom_models()
list_custom_models(params::Dict{String,<:Any})
Returns a list of the custom models that you have created with the
CreateModelCustomizationJob operation. For more information, see Custom models in the
Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"baseModelArnEquals"`: Return custom models only if the base model Amazon Resource Name
(ARN) matches this parameter.
- `"creationTimeAfter"`: Return custom models created after the specified time.
- `"creationTimeBefore"`: Return custom models created before the specified time.
- `"foundationModelArnEquals"`: Return custom models only if the foundation model Amazon
Resource Name (ARN) matches this parameter.
- `"maxResults"`: Maximum number of results to return in the response.
- `"nameContains"`: Return custom models only if the job name contains these characters.
- `"nextToken"`: Continuation token from the previous response, for Amazon Bedrock to list
the next set of results.
- `"sortBy"`: The field to sort by in the returned list of models.
- `"sortOrder"`: The sort order of the results.
"""
function list_custom_models(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"GET", "/custom-models"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_custom_models(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/custom-models",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_evaluation_jobs()
list_evaluation_jobs(params::Dict{String,<:Any})
Lists model evaluation jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"creationTimeAfter"`: A filter that includes model evaluation jobs created after the
time specified.
- `"creationTimeBefore"`: A filter that includes model evaluation jobs created prior to the
time specified.
- `"maxResults"`: The maximum number of results to return.
- `"nameContains"`: Query parameter string for model evaluation job names.
- `"nextToken"`: Continuation token from the previous response, for Amazon Bedrock to list
the next set of results.
- `"sortBy"`: Allows you to sort model evaluation jobs by when they were created.
- `"sortOrder"`: How you want the order of jobs sorted.
- `"statusEquals"`: Only return jobs where the status condition is met.
"""
function list_evaluation_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"GET", "/evaluation-jobs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_evaluation_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/evaluation-jobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_foundation_models()
list_foundation_models(params::Dict{String,<:Any})
Lists Amazon Bedrock foundation models that you can use. You can filter the results with
the request parameters. For more information, see Foundation models in the Amazon Bedrock
User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"byCustomizationType"`: Return models that support the customization type that you
specify. For more information, see Custom models in the Amazon Bedrock User Guide.
- `"byInferenceType"`: Return models that support the inference type that you specify. For
more information, see Provisioned Throughput in the Amazon Bedrock User Guide.
- `"byOutputModality"`: Return models that support the output modality that you specify.
- `"byProvider"`: Return models belonging to the model provider that you specify.
"""
function list_foundation_models(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"GET", "/foundation-models"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_foundation_models(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/foundation-models",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_guardrails()
list_guardrails(params::Dict{String,<:Any})
Lists details about all the guardrails in an account. To list the DRAFT version of all your
guardrails, don't specify the guardrailIdentifier field. To list all versions of a
guardrail, specify the ARN of the guardrail in the guardrailIdentifier field. You can set
the maximum number of results to return in a response in the maxResults field. If there are
more results than the number you set, the response returns a nextToken that you can send in
another ListGuardrails request to see the next batch of results.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"guardrailIdentifier"`: The unique identifier of the guardrail.
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: If there are more results than were returned in the response, the response
returns a nextToken that you can send in another ListGuardrails request to see the next
batch of results.
"""
function list_guardrails(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"GET", "/guardrails"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_guardrails(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET", "/guardrails", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_model_customization_jobs()
list_model_customization_jobs(params::Dict{String,<:Any})
Returns a list of model customization jobs that you have submitted. You can filter the jobs
to return based on one or more criteria. For more information, see Custom models in the
Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"creationTimeAfter"`: Return customization jobs created after the specified time.
- `"creationTimeBefore"`: Return customization jobs created before the specified time.
- `"maxResults"`: Maximum number of results to return in the response.
- `"nameContains"`: Return customization jobs only if the job name contains these
characters.
- `"nextToken"`: Continuation token from the previous response, for Amazon Bedrock to list
the next set of results.
- `"sortBy"`: The field to sort by in the returned list of jobs.
- `"sortOrder"`: The sort order of the results.
- `"statusEquals"`: Return customization jobs with the specified status.
"""
function list_model_customization_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"GET",
"/model-customization-jobs";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_model_customization_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/model-customization-jobs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_provisioned_model_throughputs()
list_provisioned_model_throughputs(params::Dict{String,<:Any})
Lists the Provisioned Throughputs in the account. For more information, see Provisioned
Throughput in the Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"creationTimeAfter"`: A filter that returns Provisioned Throughputs created after the
specified time.
- `"creationTimeBefore"`: A filter that returns Provisioned Throughputs created before the
specified time.
- `"maxResults"`: THe maximum number of results to return in the response. If there are
more results than the number you specified, the response returns a nextToken value. To see
the next batch of results, send the nextToken value in another list request.
- `"modelArnEquals"`: A filter that returns Provisioned Throughputs whose model Amazon
Resource Name (ARN) is equal to the value that you specify.
- `"nameContains"`: A filter that returns Provisioned Throughputs if their name contains
the expression that you specify.
- `"nextToken"`: If there are more results than the number you specified in the maxResults
field, the response returns a nextToken value. To see the next batch of results, specify
the nextToken value in this field.
- `"sortBy"`: The field by which to sort the returned list of Provisioned Throughputs.
- `"sortOrder"`: The sort order of the results.
- `"statusEquals"`: A filter that returns Provisioned Throughputs if their statuses matches
the value that you specify.
"""
function list_provisioned_model_throughputs(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/provisioned-model-throughputs";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_provisioned_model_throughputs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"GET",
"/provisioned-model-throughputs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
List the tags associated with the specified resource. For more information, see Tagging
resources in the Amazon Bedrock User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource.
"""
function list_tags_for_resource(
resourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"POST",
"/listTagsForResource",
Dict{String,Any}("resourceARN" => resourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/listTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceARN" => resourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_model_invocation_logging_configuration(logging_config)
put_model_invocation_logging_configuration(logging_config, params::Dict{String,<:Any})
Set the configuration values for model invocation logging.
# Arguments
- `logging_config`: The logging configuration values to set.
"""
function put_model_invocation_logging_configuration(
loggingConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"PUT",
"/logging/modelinvocations",
Dict{String,Any}("loggingConfig" => loggingConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_model_invocation_logging_configuration(
loggingConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"PUT",
"/logging/modelinvocations",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("loggingConfig" => loggingConfig), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_evaluation_job(job_identifier)
stop_evaluation_job(job_identifier, params::Dict{String,<:Any})
Stops an in progress model evaluation job.
# Arguments
- `job_identifier`: The ARN of the model evaluation job you want to stop.
"""
function stop_evaluation_job(
jobIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"POST",
"/evaluation-job/$(jobIdentifier)/stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_evaluation_job(
jobIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/evaluation-job/$(jobIdentifier)/stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_model_customization_job(job_identifier)
stop_model_customization_job(job_identifier, params::Dict{String,<:Any})
Stops an active model customization job. For more information, see Custom models in the
Amazon Bedrock User Guide.
# Arguments
- `job_identifier`: Job identifier of the job to stop.
"""
function stop_model_customization_job(
jobIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"POST",
"/model-customization-jobs/$(jobIdentifier)/stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_model_customization_job(
jobIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/model-customization-jobs/$(jobIdentifier)/stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associate tags with a resource. For more information, see Tagging resources in the Amazon
Bedrock User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to tag.
- `tags`: Tags to associate with the resource.
"""
function tag_resource(resourceARN, tags; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock(
"POST",
"/tagResource",
Dict{String,Any}("resourceARN" => resourceARN, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceARN,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/tagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceARN" => resourceARN, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Remove one or more tags from a resource. For more information, see Tagging resources in the
Amazon Bedrock User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to untag.
- `tag_keys`: Tag keys of the tags to remove from the resource.
"""
function untag_resource(
resourceARN, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"POST",
"/untagResource",
Dict{String,Any}("resourceARN" => resourceARN, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceARN,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"POST",
"/untagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceARN" => resourceARN, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_guardrail(blocked_input_messaging, blocked_outputs_messaging, guardrail_identifier, name)
update_guardrail(blocked_input_messaging, blocked_outputs_messaging, guardrail_identifier, name, params::Dict{String,<:Any})
Updates a guardrail with the values you specify. Specify a name and optional description.
Specify messages for when the guardrail successfully blocks a prompt or a model response
in the blockedInputMessaging and blockedOutputsMessaging fields. Specify topics for the
guardrail to deny in the topicPolicyConfig object. Each GuardrailTopicConfig object in the
topicsConfig list pertains to one topic. Give a name and description so that the
guardrail can properly identify the topic. Specify DENY in the type field. (Optional)
Provide up to five prompts that you would categorize as belonging to the topic in the
examples list. Specify filter strengths for the harmful categories defined in Amazon
Bedrock in the contentPolicyConfig object. Each GuardrailContentFilterConfig object in the
filtersConfig list pertains to a harmful category. For more information, see Content
filters. For more information about the fields in a content filter, see
GuardrailContentFilterConfig. Specify the category in the type field. Specify the
strength of the filter for prompts in the inputStrength field and for model responses in
the strength field of the GuardrailContentFilterConfig. (Optional) For security,
include the ARN of a KMS key in the kmsKeyId field. (Optional) Attach any tags to the
guardrail in the tags object. For more information, see Tag resources.
# Arguments
- `blocked_input_messaging`: The message to return when the guardrail blocks a prompt.
- `blocked_outputs_messaging`: The message to return when the guardrail blocks a model
response.
- `guardrail_identifier`: The unique identifier of the guardrail
- `name`: A name for the guardrail.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contentPolicyConfig"`: The content policy to configure for the guardrail.
- `"description"`: A description of the guardrail.
- `"kmsKeyId"`: The ARN of the KMS key with which to encrypt the guardrail.
- `"sensitiveInformationPolicyConfig"`: The sensitive information policy to configure for
the guardrail.
- `"topicPolicyConfig"`: The topic policy to configure for the guardrail.
- `"wordPolicyConfig"`: The word policy to configure for the guardrail.
"""
function update_guardrail(
blockedInputMessaging,
blockedOutputsMessaging,
guardrailIdentifier,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"PUT",
"/guardrails/$(guardrailIdentifier)",
Dict{String,Any}(
"blockedInputMessaging" => blockedInputMessaging,
"blockedOutputsMessaging" => blockedOutputsMessaging,
"name" => name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_guardrail(
blockedInputMessaging,
blockedOutputsMessaging,
guardrailIdentifier,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"PUT",
"/guardrails/$(guardrailIdentifier)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"blockedInputMessaging" => blockedInputMessaging,
"blockedOutputsMessaging" => blockedOutputsMessaging,
"name" => name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_provisioned_model_throughput(provisioned_model_id)
update_provisioned_model_throughput(provisioned_model_id, params::Dict{String,<:Any})
Updates the name or associated model for a Provisioned Throughput. For more information,
see Provisioned Throughput in the Amazon Bedrock User Guide.
# Arguments
- `provisioned_model_id`: The Amazon Resource Name (ARN) or name of the Provisioned
Throughput to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"desiredModelId"`: The Amazon Resource Name (ARN) of the new model to associate with
this Provisioned Throughput. You can't specify this field if this Provisioned Throughput is
associated with a base model. If this Provisioned Throughput is associated with a custom
model, you can specify one of the following options: The base model from which the custom
model was customized. Another custom model that was customized from the same base model
as the custom model.
- `"desiredProvisionedModelName"`: The new name for this Provisioned Throughput.
"""
function update_provisioned_model_throughput(
provisionedModelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock(
"PATCH",
"/provisioned-model-throughput/$(provisionedModelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_provisioned_model_throughput(
provisionedModelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock(
"PATCH",
"/provisioned-model-throughput/$(provisionedModelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 67080 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: bedrock_agent
using AWS.Compat
using AWS.UUIDs
"""
associate_agent_knowledge_base(agent_id, agent_version, description, knowledge_base_id)
associate_agent_knowledge_base(agent_id, agent_version, description, knowledge_base_id, params::Dict{String,<:Any})
Associates a knowledge base with an agent. If a knowledge base is associated and its
indexState is set to Enabled, the agent queries the knowledge base for information to
augment its response to the user.
# Arguments
- `agent_id`: The unique identifier of the agent with which you want to associate the
knowledge base.
- `agent_version`: The version of the agent with which you want to associate the knowledge
base.
- `description`: A description of what the agent should use the knowledge base for.
- `knowledge_base_id`: The unique identifier of the knowledge base to associate with the
agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"knowledgeBaseState"`: Specifies whether to use the knowledge base or not when sending
an InvokeAgent request.
"""
function associate_agent_knowledge_base(
agentId,
agentVersion,
description,
knowledgeBaseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/",
Dict{String,Any}(
"description" => description, "knowledgeBaseId" => knowledgeBaseId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_agent_knowledge_base(
agentId,
agentVersion,
description,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"description" => description, "knowledgeBaseId" => knowledgeBaseId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_agent(agent_name)
create_agent(agent_name, params::Dict{String,<:Any})
Creates an agent that orchestrates interactions between foundation models, data sources,
software applications, user conversations, and APIs to carry out tasks to help customers.
Specify the following fields for security purposes. agentResourceRoleArn – The Amazon
Resource Name (ARN) of the role with permissions to invoke API operations on an agent.
(Optional) customerEncryptionKeyArn – The Amazon Resource Name (ARN) of a KMS key to
encrypt the creation of the agent. (Optional) idleSessionTTLinSeconds – Specify the
number of seconds for which the agent should maintain session information. After this time
expires, the subsequent InvokeAgent request begins a new session. To override the
default prompt behavior for agent orchestration and to use advanced prompts, include a
promptOverrideConfiguration object. For more information, see Advanced prompts. If you
agent fails to be created, the response returns a list of failureReasons alongside a list
of recommendedActions for you to troubleshoot.
# Arguments
- `agent_name`: A name for the agent that you create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"agentResourceRoleArn"`: The Amazon Resource Name (ARN) of the IAM role with permissions
to invoke API operations on the agent.
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"customerEncryptionKeyArn"`: The Amazon Resource Name (ARN) of the KMS key with which to
encrypt the agent.
- `"description"`: A description of the agent.
- `"foundationModel"`: The foundation model to be used for orchestration by the agent you
create.
- `"guardrailConfiguration"`: The unique Guardrail configuration assigned to the agent when
it is created.
- `"idleSessionTTLInSeconds"`: The number of seconds for which Amazon Bedrock keeps
information about a user's conversation with the agent. A user interaction remains active
for the amount of time specified. If no conversation occurs during this time, the session
expires and Amazon Bedrock deletes any data provided before the timeout.
- `"instruction"`: Instructions that tell the agent what it should do and how it should
interact with users.
- `"promptOverrideConfiguration"`: Contains configurations to override prompts in different
parts of an agent sequence. For more information, see Advanced prompts.
- `"tags"`: Any tags that you want to attach to the agent.
"""
function create_agent(agentName; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"PUT",
"/agents/",
Dict{String,Any}("agentName" => agentName, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_agent(
agentName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"agentName" => agentName, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_agent_action_group(action_group_name, agent_id, agent_version)
create_agent_action_group(action_group_name, agent_id, agent_version, params::Dict{String,<:Any})
Creates an action group for an agent. An action group represents the actions that an agent
can carry out for the customer by defining the APIs that an agent can call and the logic
for calling them. To allow your agent to request the user for additional information when
trying to complete a task, add an action group with the parentActionGroupSignature field
set to AMAZON.UserInput. You must leave the description, apiSchema, and actionGroupExecutor
fields blank for this action group. During orchestration, if your agent determines that it
needs to invoke an API in an action group, but doesn't have enough information to complete
the API request, it will invoke this action group instead and return an Observation
reprompting the user for more information.
# Arguments
- `action_group_name`: The name to give the action group.
- `agent_id`: The unique identifier of the agent for which to create the action group.
- `agent_version`: The version of the agent for which to create the action group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actionGroupExecutor"`: The Amazon Resource Name (ARN) of the Lambda function containing
the business logic that is carried out upon invoking the action or the custom control
method for handling the information elicited from the user.
- `"actionGroupState"`: Specifies whether the action group is available for the agent to
invoke or not when sending an InvokeAgent request.
- `"apiSchema"`: Contains either details about the S3 object containing the OpenAPI schema
for the action group or the JSON or YAML-formatted payload defining the schema. For more
information, see Action group OpenAPI schemas.
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"description"`: A description of the action group.
- `"functionSchema"`: Contains details about the function schema for the action group or
the JSON or YAML-formatted payload defining the schema.
- `"parentActionGroupSignature"`: To allow your agent to request the user for additional
information when trying to complete a task, set this field to AMAZON.UserInput. You must
leave the description, apiSchema, and actionGroupExecutor fields blank for this action
group. During orchestration, if your agent determines that it needs to invoke an API in an
action group, but doesn't have enough information to complete the API request, it will
invoke this action group instead and return an Observation reprompting the user for more
information.
"""
function create_agent_action_group(
actionGroupName,
agentId,
agentVersion;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/",
Dict{String,Any}(
"actionGroupName" => actionGroupName, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_agent_action_group(
actionGroupName,
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"actionGroupName" => actionGroupName, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_agent_alias(agent_alias_name, agent_id)
create_agent_alias(agent_alias_name, agent_id, params::Dict{String,<:Any})
Creates an alias of an agent that can be used to deploy the agent.
# Arguments
- `agent_alias_name`: The name of the alias.
- `agent_id`: The unique identifier of the agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"description"`: A description of the alias of the agent.
- `"routingConfiguration"`: Contains details about the routing configuration of the alias.
- `"tags"`: Any tags that you want to attach to the alias of the agent.
"""
function create_agent_alias(
agentAliasName, agentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentaliases/",
Dict{String,Any}(
"agentAliasName" => agentAliasName, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_agent_alias(
agentAliasName,
agentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentaliases/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"agentAliasName" => agentAliasName, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_data_source(data_source_configuration, knowledge_base_id, name)
create_data_source(data_source_configuration, knowledge_base_id, name, params::Dict{String,<:Any})
Sets up a data source to be added to a knowledge base. You can't change the
chunkingConfiguration after you create the data source.
# Arguments
- `data_source_configuration`: Contains metadata about where the data source is stored.
- `knowledge_base_id`: The unique identifier of the knowledge base to which to add the data
source.
- `name`: The name of the data source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"dataDeletionPolicy"`: The data deletion policy assigned to the data source.
- `"description"`: A description of the data source.
- `"serverSideEncryptionConfiguration"`: Contains details about the server-side encryption
for the data source.
- `"vectorIngestionConfiguration"`: Contains details about how to ingest the documents in
the data source.
"""
function create_data_source(
dataSourceConfiguration,
knowledgeBaseId,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/",
Dict{String,Any}(
"dataSourceConfiguration" => dataSourceConfiguration,
"name" => name,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_data_source(
dataSourceConfiguration,
knowledgeBaseId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"dataSourceConfiguration" => dataSourceConfiguration,
"name" => name,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_knowledge_base(knowledge_base_configuration, name, role_arn, storage_configuration)
create_knowledge_base(knowledge_base_configuration, name, role_arn, storage_configuration, params::Dict{String,<:Any})
Creates a knowledge base that contains data sources from which information can be queried
and used by LLMs. To create a knowledge base, you must first set up your data sources and
configure a supported vector store. For more information, see Set up your data for
ingestion. If you prefer to let Amazon Bedrock create and manage a vector store for you in
Amazon OpenSearch Service, use the console. For more information, see Create a knowledge
base. Provide the name and an optional description. Provide the Amazon Resource Name
(ARN) with permissions to create a knowledge base in the roleArn field. Provide the
embedding model to use in the embeddingModelArn field in the knowledgeBaseConfiguration
object. Provide the configuration for your vector store in the storageConfiguration
object. For an Amazon OpenSearch Service database, use the
opensearchServerlessConfiguration object. For more information, see Create a vector store
in Amazon OpenSearch Service. For an Amazon Aurora database, use the RdsConfiguration
object. For more information, see Create a vector store in Amazon Aurora. For a Pinecone
database, use the pineconeConfiguration object. For more information, see Create a vector
store in Pinecone. For a Redis Enterprise Cloud database, use the
redisEnterpriseCloudConfiguration object. For more information, see Create a vector store
in Redis Enterprise Cloud.
# Arguments
- `knowledge_base_configuration`: Contains details about the embeddings model used for the
knowledge base.
- `name`: A name for the knowledge base.
- `role_arn`: The Amazon Resource Name (ARN) of the IAM role with permissions to invoke API
operations on the knowledge base.
- `storage_configuration`: Contains details about the configuration of the vector database
used for the knowledge base.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"description"`: A description of the knowledge base.
- `"tags"`: Specify the key-value pairs for the tags that you want to attach to your
knowledge base in this object.
"""
function create_knowledge_base(
knowledgeBaseConfiguration,
name,
roleArn,
storageConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/",
Dict{String,Any}(
"knowledgeBaseConfiguration" => knowledgeBaseConfiguration,
"name" => name,
"roleArn" => roleArn,
"storageConfiguration" => storageConfiguration,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_knowledge_base(
knowledgeBaseConfiguration,
name,
roleArn,
storageConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"knowledgeBaseConfiguration" => knowledgeBaseConfiguration,
"name" => name,
"roleArn" => roleArn,
"storageConfiguration" => storageConfiguration,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_agent(agent_id)
delete_agent(agent_id, params::Dict{String,<:Any})
Deletes an agent.
# Arguments
- `agent_id`: The unique identifier of the agent to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"skipResourceInUseCheck"`: By default, this value is false and deletion is stopped if
the resource is in use. If you set it to true, the resource will be deleted even if the
resource is in use.
"""
function delete_agent(agentId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_agent(
agentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_agent_action_group(action_group_id, agent_id, agent_version)
delete_agent_action_group(action_group_id, agent_id, agent_version, params::Dict{String,<:Any})
Deletes an action group in an agent.
# Arguments
- `action_group_id`: The unique identifier of the action group to delete.
- `agent_id`: The unique identifier of the agent that the action group belongs to.
- `agent_version`: The version of the agent that the action group belongs to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"skipResourceInUseCheck"`: By default, this value is false and deletion is stopped if
the resource is in use. If you set it to true, the resource will be deleted even if the
resource is in use.
"""
function delete_agent_action_group(
actionGroupId, agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_agent_action_group(
actionGroupId,
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_agent_alias(agent_alias_id, agent_id)
delete_agent_alias(agent_alias_id, agent_id, params::Dict{String,<:Any})
Deletes an alias of an agent.
# Arguments
- `agent_alias_id`: The unique identifier of the alias to delete.
- `agent_id`: The unique identifier of the agent that the alias belongs to.
"""
function delete_agent_alias(
agentAliasId, agentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_agent_alias(
agentAliasId,
agentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_agent_version(agent_id, agent_version)
delete_agent_version(agent_id, agent_version, params::Dict{String,<:Any})
Deletes a version of an agent.
# Arguments
- `agent_id`: The unique identifier of the agent that the version belongs to.
- `agent_version`: The version of the agent to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"skipResourceInUseCheck"`: By default, this value is false and deletion is stopped if
the resource is in use. If you set it to true, the resource will be deleted even if the
resource is in use.
"""
function delete_agent_version(
agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_agent_version(
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_data_source(data_source_id, knowledge_base_id)
delete_data_source(data_source_id, knowledge_base_id, params::Dict{String,<:Any})
Deletes a data source from a knowledge base.
# Arguments
- `data_source_id`: The unique identifier of the data source to delete.
- `knowledge_base_id`: The unique identifier of the knowledge base from which to delete the
data source.
"""
function delete_data_source(
dataSourceId, knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_data_source(
dataSourceId,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_knowledge_base(knowledge_base_id)
delete_knowledge_base(knowledge_base_id, params::Dict{String,<:Any})
Deletes a knowledge base. Before deleting a knowledge base, you should disassociate the
knowledge base from any agents that it is associated with by making a
DisassociateAgentKnowledgeBase request.
# Arguments
- `knowledge_base_id`: The unique identifier of the knowledge base to delete.
"""
function delete_knowledge_base(
knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/knowledgebases/$(knowledgeBaseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_knowledge_base(
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/knowledgebases/$(knowledgeBaseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_agent_knowledge_base(agent_id, agent_version, knowledge_base_id)
disassociate_agent_knowledge_base(agent_id, agent_version, knowledge_base_id, params::Dict{String,<:Any})
Disassociates a knowledge base from an agent.
# Arguments
- `agent_id`: The unique identifier of the agent from which to disassociate the knowledge
base.
- `agent_version`: The version of the agent from which to disassociate the knowledge base.
- `knowledge_base_id`: The unique identifier of the knowledge base to disassociate.
"""
function disassociate_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_agent(agent_id)
get_agent(agent_id, params::Dict{String,<:Any})
Gets information about an agent.
# Arguments
- `agent_id`: The unique identifier of the agent.
"""
function get_agent(agentId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"GET", "/agents/$(agentId)/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_agent(
agentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_agent_action_group(action_group_id, agent_id, agent_version)
get_agent_action_group(action_group_id, agent_id, agent_version, params::Dict{String,<:Any})
Gets information about an action group for an agent.
# Arguments
- `action_group_id`: The unique identifier of the action group for which to get information.
- `agent_id`: The unique identifier of the agent that the action group belongs to.
- `agent_version`: The version of the agent that the action group belongs to.
"""
function get_agent_action_group(
actionGroupId, agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_agent_action_group(
actionGroupId,
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_agent_alias(agent_alias_id, agent_id)
get_agent_alias(agent_alias_id, agent_id, params::Dict{String,<:Any})
Gets information about an alias of an agent.
# Arguments
- `agent_alias_id`: The unique identifier of the alias for which to get information.
- `agent_id`: The unique identifier of the agent to which the alias to get information
belongs.
"""
function get_agent_alias(
agentAliasId, agentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_agent_alias(
agentAliasId,
agentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_agent_knowledge_base(agent_id, agent_version, knowledge_base_id)
get_agent_knowledge_base(agent_id, agent_version, knowledge_base_id, params::Dict{String,<:Any})
Gets information about a knowledge base associated with an agent.
# Arguments
- `agent_id`: The unique identifier of the agent with which the knowledge base is
associated.
- `agent_version`: The version of the agent with which the knowledge base is associated.
- `knowledge_base_id`: The unique identifier of the knowledge base associated with the
agent.
"""
function get_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_agent_version(agent_id, agent_version)
get_agent_version(agent_id, agent_version, params::Dict{String,<:Any})
Gets details about a version of an agent.
# Arguments
- `agent_id`: The unique identifier of the agent.
- `agent_version`: The version of the agent.
"""
function get_agent_version(
agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_agent_version(
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/agents/$(agentId)/agentversions/$(agentVersion)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_data_source(data_source_id, knowledge_base_id)
get_data_source(data_source_id, knowledge_base_id, params::Dict{String,<:Any})
Gets information about a data source.
# Arguments
- `data_source_id`: The unique identifier of the data source.
- `knowledge_base_id`: The unique identifier of the knowledge base that the data source was
added to.
"""
function get_data_source(
dataSourceId, knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_source(
dataSourceId,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_ingestion_job(data_source_id, ingestion_job_id, knowledge_base_id)
get_ingestion_job(data_source_id, ingestion_job_id, knowledge_base_id, params::Dict{String,<:Any})
Gets information about a ingestion job, in which a data source is added to a knowledge base.
# Arguments
- `data_source_id`: The unique identifier of the data source in the ingestion job.
- `ingestion_job_id`: The unique identifier of the ingestion job.
- `knowledge_base_id`: The unique identifier of the knowledge base for which the ingestion
job applies.
"""
function get_ingestion_job(
dataSourceId,
ingestionJobId,
knowledgeBaseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/$(ingestionJobId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_ingestion_job(
dataSourceId,
ingestionJobId,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/$(ingestionJobId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_knowledge_base(knowledge_base_id)
get_knowledge_base(knowledge_base_id, params::Dict{String,<:Any})
Gets information about a knoweldge base.
# Arguments
- `knowledge_base_id`: The unique identifier of the knowledge base for which to get
information.
"""
function get_knowledge_base(
knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_knowledge_base(
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/knowledgebases/$(knowledgeBaseId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_agent_action_groups(agent_id, agent_version)
list_agent_action_groups(agent_id, agent_version, params::Dict{String,<:Any})
Lists the action groups for an agent and information about each one.
# Arguments
- `agent_id`: The unique identifier of the agent.
- `agent_version`: The version of the agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_agent_action_groups(
agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_agent_action_groups(
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_agent_aliases(agent_id)
list_agent_aliases(agent_id, params::Dict{String,<:Any})
Lists the aliases of an agent and information about each one.
# Arguments
- `agent_id`: The unique identifier of the agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_agent_aliases(agentId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentaliases/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_agent_aliases(
agentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentaliases/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_agent_knowledge_bases(agent_id, agent_version)
list_agent_knowledge_bases(agent_id, agent_version, params::Dict{String,<:Any})
Lists knowledge bases associated with an agent and information about each one.
# Arguments
- `agent_id`: The unique identifier of the agent for which to return information about
knowledge bases associated with it.
- `agent_version`: The version of the agent for which to return information about knowledge
bases associated with it.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_agent_knowledge_bases(
agentId, agentVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_agent_knowledge_bases(
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_agent_versions(agent_id)
list_agent_versions(agent_id, params::Dict{String,<:Any})
Lists the versions of an agent and information about each version.
# Arguments
- `agent_id`: The unique identifier of the agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_agent_versions(agentId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_agent_versions(
agentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/agentversions/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_agents()
list_agents(params::Dict{String,<:Any})
Lists the agents belonging to an account and information about each agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_agents(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST", "/agents/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_agents(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST", "/agents/", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_data_sources(knowledge_base_id)
list_data_sources(knowledge_base_id, params::Dict{String,<:Any})
Lists the data sources in a knowledge base and information about each one.
# Arguments
- `knowledge_base_id`: The unique identifier of the knowledge base for which to return a
list of information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_data_sources(
knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/knowledgebases/$(knowledgeBaseId)/datasources/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_data_sources(
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"POST",
"/knowledgebases/$(knowledgeBaseId)/datasources/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_ingestion_jobs(data_source_id, knowledge_base_id)
list_ingestion_jobs(data_source_id, knowledge_base_id, params::Dict{String,<:Any})
Lists the ingestion jobs for a data source and information about each of them.
# Arguments
- `data_source_id`: The unique identifier of the data source for which to return ingestion
jobs.
- `knowledge_base_id`: The unique identifier of the knowledge base for which to return
ingestion jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: Contains a definition of a filter for which to filter the results.
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
- `"sortBy"`: Contains details about how to sort the results.
"""
function list_ingestion_jobs(
dataSourceId, knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_ingestion_jobs(
dataSourceId,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"POST",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_knowledge_bases()
list_knowledge_bases(params::Dict{String,<:Any})
Lists the knowledge bases in an account and information about each of them.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. If the total
number of results is greater than this value, use the token returned in the response in the
nextToken field when making another request to return the next batch of results.
- `"nextToken"`: If the total number of results is greater than the maxResults value
provided in the request, enter the token returned in the nextToken field in the response in
this field to return the next batch of results.
"""
function list_knowledge_bases(; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST", "/knowledgebases/"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_knowledge_bases(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/knowledgebases/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
List all the tags for the resource you specify.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource for which to list tags.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
prepare_agent(agent_id)
prepare_agent(agent_id, params::Dict{String,<:Any})
Creates a DRAFT version of the agent that can be used for internal testing.
# Arguments
- `agent_id`: The unique identifier of the agent for which to create a DRAFT version.
"""
function prepare_agent(agentId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST",
"/agents/$(agentId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function prepare_agent(
agentId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"POST",
"/agents/$(agentId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_ingestion_job(data_source_id, knowledge_base_id)
start_ingestion_job(data_source_id, knowledge_base_id, params::Dict{String,<:Any})
Begins an ingestion job, in which a data source is added to a knowledge base.
# Arguments
- `data_source_id`: The unique identifier of the data source to ingest.
- `knowledge_base_id`: The unique identifier of the knowledge base to which to add the data
source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A unique, case-sensitive identifier to ensure that the API request
completes no more than one time. If this token matches a previous request, Amazon Bedrock
ignores the request, but does not return an error. For more information, see Ensuring
idempotency.
- `"description"`: A description of the ingestion job.
"""
function start_ingestion_job(
dataSourceId, knowledgeBaseId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/",
Dict{String,Any}("clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_ingestion_job(
dataSourceId,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)/ingestionjobs/",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => string(uuid4())), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associate tags with a resource. For more information, see Tagging resources in the Amazon
Bedrock User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to tag.
- `tags`: An object containing key-value pairs that define the tags to attach to the
resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Remove tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource from which to remove tags.
- `tag_keys`: A list of keys of the tags to remove from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_agent(agent_id, agent_name, agent_resource_role_arn, foundation_model)
update_agent(agent_id, agent_name, agent_resource_role_arn, foundation_model, params::Dict{String,<:Any})
Updates the configuration of an agent.
# Arguments
- `agent_id`: The unique identifier of the agent.
- `agent_name`: Specifies a new name for the agent.
- `agent_resource_role_arn`: The Amazon Resource Name (ARN) of the IAM role with
permissions to invoke API operations on the agent.
- `foundation_model`: Specifies a new foundation model to be used for orchestration by the
agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"customerEncryptionKeyArn"`: The Amazon Resource Name (ARN) of the KMS key with which to
encrypt the agent.
- `"description"`: Specifies a new description of the agent.
- `"guardrailConfiguration"`: The unique Guardrail configuration assigned to the agent when
it is updated.
- `"idleSessionTTLInSeconds"`: The number of seconds for which Amazon Bedrock keeps
information about a user's conversation with the agent. A user interaction remains active
for the amount of time specified. If no conversation occurs during this time, the session
expires and Amazon Bedrock deletes any data provided before the timeout.
- `"instruction"`: Specifies new instructions that tell the agent what it should do and how
it should interact with users.
- `"promptOverrideConfiguration"`: Contains configurations to override prompts in different
parts of an agent sequence. For more information, see Advanced prompts.
"""
function update_agent(
agentId,
agentName,
agentResourceRoleArn,
foundationModel;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/",
Dict{String,Any}(
"agentName" => agentName,
"agentResourceRoleArn" => agentResourceRoleArn,
"foundationModel" => foundationModel,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_agent(
agentId,
agentName,
agentResourceRoleArn,
foundationModel,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"agentName" => agentName,
"agentResourceRoleArn" => agentResourceRoleArn,
"foundationModel" => foundationModel,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_agent_action_group(action_group_id, action_group_name, agent_id, agent_version)
update_agent_action_group(action_group_id, action_group_name, agent_id, agent_version, params::Dict{String,<:Any})
Updates the configuration for an action group for an agent.
# Arguments
- `action_group_id`: The unique identifier of the action group.
- `action_group_name`: Specifies a new name for the action group.
- `agent_id`: The unique identifier of the agent for which to update the action group.
- `agent_version`: The unique identifier of the agent version for which to update the
action group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actionGroupExecutor"`: The Amazon Resource Name (ARN) of the Lambda function containing
the business logic that is carried out upon invoking the action.
- `"actionGroupState"`: Specifies whether the action group is available for the agent to
invoke or not when sending an InvokeAgent request.
- `"apiSchema"`: Contains either details about the S3 object containing the OpenAPI schema
for the action group or the JSON or YAML-formatted payload defining the schema. For more
information, see Action group OpenAPI schemas.
- `"description"`: Specifies a new name for the action group.
- `"functionSchema"`: Contains details about the function schema for the action group or
the JSON or YAML-formatted payload defining the schema.
- `"parentActionGroupSignature"`: To allow your agent to request the user for additional
information when trying to complete a task, set this field to AMAZON.UserInput. You must
leave the description, apiSchema, and actionGroupExecutor fields blank for this action
group. During orchestration, if your agent determines that it needs to invoke an API in an
action group, but doesn't have enough information to complete the API request, it will
invoke this action group instead and return an Observation reprompting the user for more
information.
"""
function update_agent_action_group(
actionGroupId,
actionGroupName,
agentId,
agentVersion;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/",
Dict{String,Any}("actionGroupName" => actionGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_agent_action_group(
actionGroupId,
actionGroupName,
agentId,
agentVersion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/actiongroups/$(actionGroupId)/",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("actionGroupName" => actionGroupName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_agent_alias(agent_alias_id, agent_alias_name, agent_id)
update_agent_alias(agent_alias_id, agent_alias_name, agent_id, params::Dict{String,<:Any})
Updates configurations for an alias of an agent.
# Arguments
- `agent_alias_id`: The unique identifier of the alias.
- `agent_alias_name`: Specifies a new name for the alias.
- `agent_id`: The unique identifier of the agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: Specifies a new description for the alias.
- `"routingConfiguration"`: Contains details about the routing configuration of the alias.
"""
function update_agent_alias(
agentAliasId, agentAliasName, agentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/",
Dict{String,Any}("agentAliasName" => agentAliasName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_agent_alias(
agentAliasId,
agentAliasName,
agentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentaliases/$(agentAliasId)/",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("agentAliasName" => agentAliasName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_agent_knowledge_base(agent_id, agent_version, knowledge_base_id)
update_agent_knowledge_base(agent_id, agent_version, knowledge_base_id, params::Dict{String,<:Any})
Updates the configuration for a knowledge base that has been associated with an agent.
# Arguments
- `agent_id`: The unique identifier of the agent associated with the knowledge base that
you want to update.
- `agent_version`: The version of the agent associated with the knowledge base that you
want to update.
- `knowledge_base_id`: The unique identifier of the knowledge base that has been associated
with an agent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: Specifies a new description for the knowledge base associated with an
agent.
- `"knowledgeBaseState"`: Specifies whether the agent uses the knowledge base or not when
sending an InvokeAgent request.
"""
function update_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_agent_knowledge_base(
agentId,
agentVersion,
knowledgeBaseId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/agents/$(agentId)/agentversions/$(agentVersion)/knowledgebases/$(knowledgeBaseId)/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_data_source(data_source_configuration, data_source_id, knowledge_base_id, name)
update_data_source(data_source_configuration, data_source_id, knowledge_base_id, name, params::Dict{String,<:Any})
Updates configurations for a data source. You can't change the chunkingConfiguration after
you create the data source. Specify the existing chunkingConfiguration.
# Arguments
- `data_source_configuration`: Contains details about the storage configuration of the data
source.
- `data_source_id`: The unique identifier of the data source.
- `knowledge_base_id`: The unique identifier of the knowledge base to which the data source
belongs.
- `name`: Specifies a new name for the data source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"dataDeletionPolicy"`: The data deletion policy of the updated data source.
- `"description"`: Specifies a new description for the data source.
- `"serverSideEncryptionConfiguration"`: Contains details about server-side encryption of
the data source.
- `"vectorIngestionConfiguration"`: Contains details about how to ingest the documents in
the data source.
"""
function update_data_source(
dataSourceConfiguration,
dataSourceId,
knowledgeBaseId,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)",
Dict{String,Any}(
"dataSourceConfiguration" => dataSourceConfiguration, "name" => name
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_data_source(
dataSourceConfiguration,
dataSourceId,
knowledgeBaseId,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)/datasources/$(dataSourceId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"dataSourceConfiguration" => dataSourceConfiguration, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_knowledge_base(knowledge_base_configuration, knowledge_base_id, name, role_arn, storage_configuration)
update_knowledge_base(knowledge_base_configuration, knowledge_base_id, name, role_arn, storage_configuration, params::Dict{String,<:Any})
Updates the configuration of a knowledge base with the fields that you specify. Because all
fields will be overwritten, you must include the same values for fields that you want to
keep the same. You can change the following fields: name description roleArn
You can't change the knowledgeBaseConfiguration or storageConfiguration fields, so you must
specify the same configurations as when you created the knowledge base. You can send a
GetKnowledgeBase request and copy the same configurations.
# Arguments
- `knowledge_base_configuration`: Specifies the configuration for the embeddings model used
for the knowledge base. You must use the same configuration as when the knowledge base was
created.
- `knowledge_base_id`: The unique identifier of the knowledge base to update.
- `name`: Specifies a new name for the knowledge base.
- `role_arn`: Specifies a different Amazon Resource Name (ARN) of the IAM role with
permissions to invoke API operations on the knowledge base.
- `storage_configuration`: Specifies the configuration for the vector store used for the
knowledge base. You must use the same configuration as when the knowledge base was created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: Specifies a new description for the knowledge base.
"""
function update_knowledge_base(
knowledgeBaseConfiguration,
knowledgeBaseId,
name,
roleArn,
storageConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)",
Dict{String,Any}(
"knowledgeBaseConfiguration" => knowledgeBaseConfiguration,
"name" => name,
"roleArn" => roleArn,
"storageConfiguration" => storageConfiguration,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_knowledge_base(
knowledgeBaseConfiguration,
knowledgeBaseId,
name,
roleArn,
storageConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent(
"PUT",
"/knowledgebases/$(knowledgeBaseId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"knowledgeBaseConfiguration" => knowledgeBaseConfiguration,
"name" => name,
"roleArn" => roleArn,
"storageConfiguration" => storageConfiguration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 6370 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: bedrock_agent_runtime
using AWS.Compat
using AWS.UUIDs
"""
invoke_agent(agent_alias_id, agent_id, session_id)
invoke_agent(agent_alias_id, agent_id, session_id, params::Dict{String,<:Any})
The CLI doesn't support InvokeAgent. Sends a prompt for the agent to process and respond
to. Note the following fields for the request: To continue the same conversation with an
agent, use the same sessionId value in the request. To activate trace enablement, turn
enableTrace to true. Trace enablement helps you follow the agent's reasoning process that
led it to the information it processed, the actions it took, and the final result it
yielded. For more information, see Trace enablement. End a conversation by setting
endSession to true. In the sessionState object, you can include attributes for the
session or prompt or, if you configured an action group to return control, results from
invocation of the action group. The response is returned in the bytes field of the chunk
object. The attribution object contains citations for parts of the response. If you set
enableTrace to true in the request, you can trace the agent's steps and reasoning process
that led it to the response. If the action predicted was configured to return control,
the response returns parameters for the action, elicited from the user, in the
returnControl field. Errors are also surfaced in the response.
# Arguments
- `agent_alias_id`: The alias of the agent to use.
- `agent_id`: The unique identifier of the agent to use.
- `session_id`: The unique identifier of the session. Use the same value across requests to
continue the same conversation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"enableTrace"`: Specifies whether to turn on the trace or not to track the agent's
reasoning process. For more information, see Trace enablement.
- `"endSession"`: Specifies whether to end the session with the agent or not.
- `"inputText"`: The prompt text to send the agent. If you include
returnControlInvocationResults in the sessionState field, the inputText field will be
ignored.
- `"sessionState"`: Contains parameters that specify various attributes of the session. For
more information, see Control session context. If you include
returnControlInvocationResults in the sessionState field, the inputText field will be
ignored.
"""
function invoke_agent(
agentAliasId, agentId, sessionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent_runtime(
"POST",
"/agents/$(agentId)/agentAliases/$(agentAliasId)/sessions/$(sessionId)/text";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function invoke_agent(
agentAliasId,
agentId,
sessionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent_runtime(
"POST",
"/agents/$(agentId)/agentAliases/$(agentAliasId)/sessions/$(sessionId)/text",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
retrieve(knowledge_base_id, retrieval_query)
retrieve(knowledge_base_id, retrieval_query, params::Dict{String,<:Any})
Queries a knowledge base and retrieves information from it.
# Arguments
- `knowledge_base_id`: The unique identifier of the knowledge base to query.
- `retrieval_query`: Contains the query to send the knowledge base.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: If there are more results than can fit in the response, the response
returns a nextToken. Use this token in the nextToken field of another request to retrieve
the next batch of results.
- `"retrievalConfiguration"`: Contains configurations for the knowledge base query and
retrieval process. For more information, see Query configurations.
"""
function retrieve(
knowledgeBaseId, retrievalQuery; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent_runtime(
"POST",
"/knowledgebases/$(knowledgeBaseId)/retrieve",
Dict{String,Any}("retrievalQuery" => retrievalQuery);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function retrieve(
knowledgeBaseId,
retrievalQuery,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_agent_runtime(
"POST",
"/knowledgebases/$(knowledgeBaseId)/retrieve",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("retrievalQuery" => retrievalQuery), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
retrieve_and_generate(input)
retrieve_and_generate(input, params::Dict{String,<:Any})
Queries a knowledge base and generates responses based on the retrieved results. The
response only cites sources that are relevant to the query.
# Arguments
- `input`: Contains the query to be made to the knowledge base.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"retrieveAndGenerateConfiguration"`: Contains configurations for the knowledge base
query and retrieval process. For more information, see Query configurations.
- `"sessionConfiguration"`: Contains details about the session with the knowledge base.
- `"sessionId"`: The unique identifier of the session. Reuse the same value to continue the
same session with the knowledge base.
"""
function retrieve_and_generate(input; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_agent_runtime(
"POST",
"/retrieveAndGenerate",
Dict{String,Any}("input" => input);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function retrieve_and_generate(
input, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_agent_runtime(
"POST",
"/retrieveAndGenerate",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("input" => input), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 15347 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: bedrock_runtime
using AWS.Compat
using AWS.UUIDs
"""
converse(messages, model_id)
converse(messages, model_id, params::Dict{String,<:Any})
Sends messages to the specified Amazon Bedrock model. Converse provides a consistent
interface that works with all models that support messages. This allows you to write code
once and use it with different models. Should a model have unique inference parameters, you
can also pass those unique parameters to the model. For information about the Converse API,
see Use the Converse API in the Amazon Bedrock User Guide. To use a guardrail, see Use a
guardrail with the Converse API in the Amazon Bedrock User Guide. To use a tool with a
model, see Tool use (Function calling) in the Amazon Bedrock User Guide For example code,
see Converse API examples in the Amazon Bedrock User Guide. This operation requires
permission for the bedrock:InvokeModel action.
# Arguments
- `messages`: The messages that you want to send to the model.
- `model_id`: The identifier for the model that you want to call. The modelId to provide
depends on the type of model that you use: If you use a base model, specify the model ID
or its ARN. For a list of model IDs for base models, see Amazon Bedrock base model IDs
(on-demand throughput) in the Amazon Bedrock User Guide. If you use a provisioned model,
specify the ARN of the Provisioned Throughput. For more information, see Run inference
using a Provisioned Throughput in the Amazon Bedrock User Guide. If you use a custom
model, first purchase Provisioned Throughput for it. Then specify the ARN of the resulting
provisioned model. For more information, see Use a custom model in Amazon Bedrock in the
Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalModelRequestFields"`: Additional inference parameters that the model
supports, beyond the base set of inference parameters that Converse supports in the
inferenceConfig field. For more information, see Model parameters.
- `"additionalModelResponseFieldPaths"`: Additional model parameters field paths to return
in the response. Converse returns the requested fields as a JSON Pointer object in the
additionalModelResponseFields field. The following is example JSON for
additionalModelResponseFieldPaths. [ \"/stop_sequence\" ] For information about the JSON
Pointer syntax, see the Internet Engineering Task Force (IETF) documentation. Converse
rejects an empty JSON Pointer or incorrectly structured JSON Pointer with a 400 error code.
if the JSON Pointer is valid, but the requested field is not in the model response, it is
ignored by Converse.
- `"guardrailConfig"`: Configuration information for a guardrail that you want to use in
the request.
- `"inferenceConfig"`: Inference parameters to pass to the model. Converse supports a base
set of inference parameters. If you need to pass additional parameters that the model
supports, use the additionalModelRequestFields request field.
- `"system"`: A system prompt to pass to the model.
- `"toolConfig"`: Configuration information for the tools that the model can use when
generating a response. This field is only supported by Anthropic Claude 3, Cohere Command
R, Cohere Command R+, and Mistral Large models.
"""
function converse(messages, modelId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_runtime(
"POST",
"/model/$(modelId)/converse",
Dict{String,Any}("messages" => messages);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function converse(
messages,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/converse",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("messages" => messages), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
converse_stream(messages, model_id)
converse_stream(messages, model_id, params::Dict{String,<:Any})
Sends messages to the specified Amazon Bedrock model and returns the response in a stream.
ConverseStream provides a consistent API that works with all Amazon Bedrock models that
support messages. This allows you to write code once and use it with different models.
Should a model have unique inference parameters, you can also pass those unique parameters
to the model. To find out if a model supports streaming, call GetFoundationModel and check
the responseStreamingSupported field in the response. For information about the Converse
API, see Use the Converse API in the Amazon Bedrock User Guide. To use a guardrail, see Use
a guardrail with the Converse API in the Amazon Bedrock User Guide. To use a tool with a
model, see Tool use (Function calling) in the Amazon Bedrock User Guide For example code,
see Conversation streaming example in the Amazon Bedrock User Guide. This operation
requires permission for the bedrock:InvokeModelWithResponseStream action.
# Arguments
- `messages`: The messages that you want to send to the model.
- `model_id`: The ID for the model. The modelId to provide depends on the type of model
that you use: If you use a base model, specify the model ID or its ARN. For a list of
model IDs for base models, see Amazon Bedrock base model IDs (on-demand throughput) in the
Amazon Bedrock User Guide. If you use a provisioned model, specify the ARN of the
Provisioned Throughput. For more information, see Run inference using a Provisioned
Throughput in the Amazon Bedrock User Guide. If you use a custom model, first purchase
Provisioned Throughput for it. Then specify the ARN of the resulting provisioned model. For
more information, see Use a custom model in Amazon Bedrock in the Amazon Bedrock User
Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalModelRequestFields"`: Additional inference parameters that the model
supports, beyond the base set of inference parameters that ConverseStream supports in the
inferenceConfig field.
- `"additionalModelResponseFieldPaths"`: Additional model parameters field paths to return
in the response. ConverseStream returns the requested fields as a JSON Pointer object in
the additionalModelResponseFields field. The following is example JSON for
additionalModelResponseFieldPaths. [ \"/stop_sequence\" ] For information about the JSON
Pointer syntax, see the Internet Engineering Task Force (IETF) documentation.
ConverseStream rejects an empty JSON Pointer or incorrectly structured JSON Pointer with a
400 error code. if the JSON Pointer is valid, but the requested field is not in the model
response, it is ignored by ConverseStream.
- `"guardrailConfig"`: Configuration information for a guardrail that you want to use in
the request.
- `"inferenceConfig"`: Inference parameters to pass to the model. ConverseStream supports a
base set of inference parameters. If you need to pass additional parameters that the model
supports, use the additionalModelRequestFields request field.
- `"system"`: A system prompt to send to the model.
- `"toolConfig"`: Configuration information for the tools that the model can use when
generating a response. This field is only supported by Anthropic Claude 3 models.
"""
function converse_stream(
messages, modelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/converse-stream",
Dict{String,Any}("messages" => messages);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function converse_stream(
messages,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/converse-stream",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("messages" => messages), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
invoke_model(body, model_id)
invoke_model(body, model_id, params::Dict{String,<:Any})
Invokes the specified Amazon Bedrock model to run inference using the prompt and inference
parameters provided in the request body. You use model inference to generate text, images,
and embeddings. For example code, see Invoke model code examples in the Amazon Bedrock User
Guide. This operation requires permission for the bedrock:InvokeModel action.
# Arguments
- `body`: The prompt and inference parameters in the format specified in the contentType in
the header. You must provide the body in JSON format. To see the format and content of the
request and response bodies for different models, refer to Inference parameters. For more
information, see Run inference in the Bedrock User Guide.
- `model_id`: The unique identifier of the model to invoke to run inference. The modelId to
provide depends on the type of model that you use: If you use a base model, specify the
model ID or its ARN. For a list of model IDs for base models, see Amazon Bedrock base model
IDs (on-demand throughput) in the Amazon Bedrock User Guide. If you use a provisioned
model, specify the ARN of the Provisioned Throughput. For more information, see Run
inference using a Provisioned Throughput in the Amazon Bedrock User Guide. If you use a
custom model, first purchase Provisioned Throughput for it. Then specify the ARN of the
resulting provisioned model. For more information, see Use a custom model in Amazon Bedrock
in the Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accept"`: The desired MIME type of the inference body in the response. The default
value is application/json.
- `"Content-Type"`: The MIME type of the input data in the request. You must specify
application/json.
- `"X-Amzn-Bedrock-GuardrailIdentifier"`: The unique identifier of the guardrail that you
want to use. If you don't provide a value, no guardrail is applied to the invocation. An
error will be thrown in the following situations. You don't provide a guardrail
identifier but you specify the amazon-bedrock-guardrailConfig field in the request body.
You enable the guardrail but the contentType isn't application/json. You provide a
guardrail identifier, but guardrailVersion isn't specified.
- `"X-Amzn-Bedrock-GuardrailVersion"`: The version number for the guardrail. The value can
also be DRAFT.
- `"X-Amzn-Bedrock-Trace"`: Specifies whether to enable or disable the Bedrock trace. If
enabled, you can see the full Bedrock trace.
"""
function invoke_model(body, modelId; aws_config::AbstractAWSConfig=global_aws_config())
return bedrock_runtime(
"POST",
"/model/$(modelId)/invoke",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function invoke_model(
body,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/invoke",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
invoke_model_with_response_stream(body, model_id)
invoke_model_with_response_stream(body, model_id, params::Dict{String,<:Any})
Invoke the specified Amazon Bedrock model to run inference using the prompt and inference
parameters provided in the request body. The response is returned in a stream. To see if a
model supports streaming, call GetFoundationModel and check the responseStreamingSupported
field in the response. The CLI doesn't support InvokeModelWithResponseStream. For example
code, see Invoke model with streaming code example in the Amazon Bedrock User Guide. This
operation requires permissions to perform the bedrock:InvokeModelWithResponseStream action.
# Arguments
- `body`: The prompt and inference parameters in the format specified in the contentType in
the header. You must provide the body in JSON format. To see the format and content of the
request and response bodies for different models, refer to Inference parameters. For more
information, see Run inference in the Bedrock User Guide.
- `model_id`: The unique identifier of the model to invoke to run inference. The modelId to
provide depends on the type of model that you use: If you use a base model, specify the
model ID or its ARN. For a list of model IDs for base models, see Amazon Bedrock base model
IDs (on-demand throughput) in the Amazon Bedrock User Guide. If you use a provisioned
model, specify the ARN of the Provisioned Throughput. For more information, see Run
inference using a Provisioned Throughput in the Amazon Bedrock User Guide. If you use a
custom model, first purchase Provisioned Throughput for it. Then specify the ARN of the
resulting provisioned model. For more information, see Use a custom model in Amazon Bedrock
in the Amazon Bedrock User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Content-Type"`: The MIME type of the input data in the request. You must specify
application/json.
- `"X-Amzn-Bedrock-Accept"`: The desired MIME type of the inference body in the response.
The default value is application/json.
- `"X-Amzn-Bedrock-GuardrailIdentifier"`: The unique identifier of the guardrail that you
want to use. If you don't provide a value, no guardrail is applied to the invocation. An
error is thrown in the following situations. You don't provide a guardrail identifier but
you specify the amazon-bedrock-guardrailConfig field in the request body. You enable the
guardrail but the contentType isn't application/json. You provide a guardrail identifier,
but guardrailVersion isn't specified.
- `"X-Amzn-Bedrock-GuardrailVersion"`: The version number for the guardrail. The value can
also be DRAFT.
- `"X-Amzn-Bedrock-Trace"`: Specifies whether to enable or disable the Bedrock trace. If
enabled, you can see the full Bedrock trace.
"""
function invoke_model_with_response_stream(
body, modelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/invoke-with-response-stream",
Dict{String,Any}("body" => body);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function invoke_model_with_response_stream(
body,
modelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return bedrock_runtime(
"POST",
"/model/$(modelId)/invoke-with-response-stream",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("body" => body), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 46656 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: billingconductor
using AWS.Compat
using AWS.UUIDs
"""
associate_accounts(account_ids, arn)
associate_accounts(account_ids, arn, params::Dict{String,<:Any})
Connects an array of account IDs in a consolidated billing family to a predefined billing
group. The account IDs must be a part of the consolidated billing family during the current
month, and not already associated with another billing group. The maximum number of
accounts that can be associated in one call is 30.
# Arguments
- `account_ids`: The associating array of account IDs.
- `arn`: The Amazon Resource Name (ARN) of the billing group that associates the array of
account IDs.
"""
function associate_accounts(
AccountIds, Arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/associate-accounts",
Dict{String,Any}("AccountIds" => AccountIds, "Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_accounts(
AccountIds,
Arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/associate-accounts",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("AccountIds" => AccountIds, "Arn" => Arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_pricing_rules(arn, pricing_rule_arns)
associate_pricing_rules(arn, pricing_rule_arns, params::Dict{String,<:Any})
Connects an array of PricingRuleArns to a defined PricingPlan. The maximum number
PricingRuleArn that can be associated in one call is 30.
# Arguments
- `arn`: The PricingPlanArn that the PricingRuleArns are associated with.
- `pricing_rule_arns`: The PricingRuleArns that are associated with the Pricing Plan.
"""
function associate_pricing_rules(
Arn, PricingRuleArns; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/associate-pricing-rules",
Dict{String,Any}("Arn" => Arn, "PricingRuleArns" => PricingRuleArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_pricing_rules(
Arn,
PricingRuleArns,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"PUT",
"/associate-pricing-rules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Arn" => Arn, "PricingRuleArns" => PricingRuleArns),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_associate_resources_to_custom_line_item(resource_arns, target_arn)
batch_associate_resources_to_custom_line_item(resource_arns, target_arn, params::Dict{String,<:Any})
Associates a batch of resources to a percentage custom line item.
# Arguments
- `resource_arns`: A list containing the ARNs of the resources to be associated.
- `target_arn`: A percentage custom line item ARN to associate the resources to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriodRange"`:
"""
function batch_associate_resources_to_custom_line_item(
ResourceArns, TargetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/batch-associate-resources-to-custom-line-item",
Dict{String,Any}("ResourceArns" => ResourceArns, "TargetArn" => TargetArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_associate_resources_to_custom_line_item(
ResourceArns,
TargetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"PUT",
"/batch-associate-resources-to-custom-line-item",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArns" => ResourceArns, "TargetArn" => TargetArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_disassociate_resources_from_custom_line_item(resource_arns, target_arn)
batch_disassociate_resources_from_custom_line_item(resource_arns, target_arn, params::Dict{String,<:Any})
Disassociates a batch of resources from a percentage custom line item.
# Arguments
- `resource_arns`: A list containing the ARNs of resources to be disassociated.
- `target_arn`: A percentage custom line item ARN to disassociate the resources from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriodRange"`:
"""
function batch_disassociate_resources_from_custom_line_item(
ResourceArns, TargetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/batch-disassociate-resources-from-custom-line-item",
Dict{String,Any}("ResourceArns" => ResourceArns, "TargetArn" => TargetArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_disassociate_resources_from_custom_line_item(
ResourceArns,
TargetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"PUT",
"/batch-disassociate-resources-from-custom-line-item",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArns" => ResourceArns, "TargetArn" => TargetArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_billing_group(account_grouping, computation_preference, name)
create_billing_group(account_grouping, computation_preference, name, params::Dict{String,<:Any})
Creates a billing group that resembles a consolidated billing family that Amazon Web
Services charges, based off of the predefined pricing plan computation.
# Arguments
- `account_grouping`: The set of accounts that will be under the billing group. The set of
accounts resemble the linked accounts in a consolidated billing family.
- `computation_preference`: The preferences and settings that will be used to compute the
Amazon Web Services charges for a billing group.
- `name`: The billing group name. The names must be unique.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the billing group.
- `"PrimaryAccountId"`: The account ID that serves as the main account in a billing group.
- `"Tags"`: A map that contains tag keys and tag values that are attached to a billing
group. This feature isn't available during the beta.
- `"X-Amzn-Client-Token"`: The token that is needed to support idempotency. Idempotency
isn't currently supported, but will be implemented in a future update.
"""
function create_billing_group(
AccountGrouping,
ComputationPreference,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/create-billing-group",
Dict{String,Any}(
"AccountGrouping" => AccountGrouping,
"ComputationPreference" => ComputationPreference,
"Name" => Name,
"X-Amzn-Client-Token" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_billing_group(
AccountGrouping,
ComputationPreference,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/create-billing-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountGrouping" => AccountGrouping,
"ComputationPreference" => ComputationPreference,
"Name" => Name,
"X-Amzn-Client-Token" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_custom_line_item(billing_group_arn, charge_details, description, name)
create_custom_line_item(billing_group_arn, charge_details, description, name, params::Dict{String,<:Any})
Creates a custom line item that can be used to create a one-time fixed charge that can be
applied to a single billing group for the current or previous billing period. The one-time
fixed charge is either a fee or discount.
# Arguments
- `billing_group_arn`: The Amazon Resource Name (ARN) that references the billing group
where the custom line item applies to.
- `charge_details`: A CustomLineItemChargeDetails that describes the charge details for a
custom line item.
- `description`: The description of the custom line item. This is shown on the Bills page
in association with the charge value.
- `name`: The name of the custom line item.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountId"`: The Amazon Web Services account in which this custom line item will be
applied to.
- `"BillingPeriodRange"`: A time range for which the custom line item is effective.
- `"Tags"`: A map that contains tag keys and tag values that are attached to a custom line
item.
- `"X-Amzn-Client-Token"`: The token that is needed to support idempotency. Idempotency
isn't currently supported, but will be implemented in a future update.
"""
function create_custom_line_item(
BillingGroupArn,
ChargeDetails,
Description,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/create-custom-line-item",
Dict{String,Any}(
"BillingGroupArn" => BillingGroupArn,
"ChargeDetails" => ChargeDetails,
"Description" => Description,
"Name" => Name,
"X-Amzn-Client-Token" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_custom_line_item(
BillingGroupArn,
ChargeDetails,
Description,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/create-custom-line-item",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BillingGroupArn" => BillingGroupArn,
"ChargeDetails" => ChargeDetails,
"Description" => Description,
"Name" => Name,
"X-Amzn-Client-Token" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_pricing_plan(name)
create_pricing_plan(name, params::Dict{String,<:Any})
Creates a pricing plan that is used for computing Amazon Web Services charges for billing
groups.
# Arguments
- `name`: The name of the pricing plan. The names must be unique to each pricing plan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the pricing plan.
- `"PricingRuleArns"`: A list of Amazon Resource Names (ARNs) that define the pricing plan
parameters.
- `"Tags"`: A map that contains tag keys and tag values that are attached to a pricing
plan.
- `"X-Amzn-Client-Token"`: The token that is needed to support idempotency. Idempotency
isn't currently supported, but will be implemented in a future update.
"""
function create_pricing_plan(Name; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/create-pricing-plan",
Dict{String,Any}("Name" => Name, "X-Amzn-Client-Token" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_pricing_plan(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/create-pricing-plan",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "X-Amzn-Client-Token" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_pricing_rule(name, scope, type)
create_pricing_rule(name, scope, type, params::Dict{String,<:Any})
Creates a pricing rule can be associated to a pricing plan, or a set of pricing plans.
# Arguments
- `name`: The pricing rule name. The names must be unique to each pricing rule.
- `scope`: The scope of pricing rule that indicates if it's globally applicable, or it's
service-specific.
- `type`: The type of pricing rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingEntity"`: The seller of services provided by Amazon Web Services, their
affiliates, or third-party providers selling services via Amazon Web Services Marketplace.
- `"Description"`: The pricing rule description.
- `"ModifierPercentage"`: A percentage modifier that's applied on the public pricing
rates.
- `"Operation"`: Operation is the specific Amazon Web Services action covered by this line
item. This describes the specific usage of the line item. If the Scope attribute is set to
SKU, this attribute indicates which operation the PricingRule is modifying. For example, a
value of RunInstances:0202 indicates the operation of running an Amazon EC2 instance.
- `"Service"`: If the Scope attribute is set to SERVICE or SKU, the attribute indicates
which service the PricingRule is applicable for.
- `"Tags"`: A map that contains tag keys and tag values that are attached to a pricing
rule.
- `"Tiering"`: The set of tiering configurations for the pricing rule.
- `"UsageType"`: Usage type is the unit that each service uses to measure the usage of a
specific type of resource. If the Scope attribute is set to SKU, this attribute indicates
which usage type the PricingRule is modifying. For example, USW2-BoxUsage:m2.2xlarge
describes an M2 High Memory Double Extra Large instance in the US West (Oregon) Region.
</p>
- `"X-Amzn-Client-Token"`: The token that's needed to support idempotency. Idempotency
isn't currently supported, but will be implemented in a future update.
"""
function create_pricing_rule(
Name, Scope, Type; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/create-pricing-rule",
Dict{String,Any}(
"Name" => Name,
"Scope" => Scope,
"Type" => Type,
"X-Amzn-Client-Token" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_pricing_rule(
Name,
Scope,
Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/create-pricing-rule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"Scope" => Scope,
"Type" => Type,
"X-Amzn-Client-Token" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_billing_group(arn)
delete_billing_group(arn, params::Dict{String,<:Any})
Deletes a billing group.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the billing group that you're deleting.
"""
function delete_billing_group(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/delete-billing-group",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_billing_group(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/delete-billing-group",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_custom_line_item(arn)
delete_custom_line_item(arn, params::Dict{String,<:Any})
Deletes the custom line item identified by the given ARN in the current, or previous
billing period.
# Arguments
- `arn`: The ARN of the custom line item to be deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriodRange"`:
"""
function delete_custom_line_item(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/delete-custom-line-item",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_custom_line_item(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/delete-custom-line-item",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_pricing_plan(arn)
delete_pricing_plan(arn, params::Dict{String,<:Any})
Deletes a pricing plan. The pricing plan must not be associated with any billing groups to
delete successfully.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the pricing plan that you're deleting.
"""
function delete_pricing_plan(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/delete-pricing-plan",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_pricing_plan(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/delete-pricing-plan",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_pricing_rule(arn)
delete_pricing_rule(arn, params::Dict{String,<:Any})
Deletes the pricing rule that's identified by the input Amazon Resource Name (ARN).
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the pricing rule that you are deleting.
"""
function delete_pricing_rule(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/delete-pricing-rule",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_pricing_rule(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/delete-pricing-rule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_accounts(account_ids, arn)
disassociate_accounts(account_ids, arn, params::Dict{String,<:Any})
Removes the specified list of account IDs from the given billing group.
# Arguments
- `account_ids`: The array of account IDs to disassociate.
- `arn`: The Amazon Resource Name (ARN) of the billing group that the array of account IDs
will disassociate from.
"""
function disassociate_accounts(
AccountIds, Arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/disassociate-accounts",
Dict{String,Any}("AccountIds" => AccountIds, "Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_accounts(
AccountIds,
Arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/disassociate-accounts",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("AccountIds" => AccountIds, "Arn" => Arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_pricing_rules(arn, pricing_rule_arns)
disassociate_pricing_rules(arn, pricing_rule_arns, params::Dict{String,<:Any})
Disassociates a list of pricing rules from a pricing plan.
# Arguments
- `arn`: The pricing plan Amazon Resource Name (ARN) to disassociate pricing rules from.
- `pricing_rule_arns`: A list containing the Amazon Resource Name (ARN) of the pricing
rules that will be disassociated.
"""
function disassociate_pricing_rules(
Arn, PricingRuleArns; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/disassociate-pricing-rules",
Dict{String,Any}("Arn" => Arn, "PricingRuleArns" => PricingRuleArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_pricing_rules(
Arn,
PricingRuleArns,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"PUT",
"/disassociate-pricing-rules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Arn" => Arn, "PricingRuleArns" => PricingRuleArns),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_billing_group_cost_report(arn)
get_billing_group_cost_report(arn, params::Dict{String,<:Any})
Retrieves the margin summary report, which includes the Amazon Web Services cost and
charged amount (pro forma cost) by Amazon Web Service for a specific billing group.
# Arguments
- `arn`: The Amazon Resource Number (ARN) that uniquely identifies the billing group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriodRange"`: A time range for which the margin summary is effective. You can
specify up to 12 months.
- `"GroupBy"`: A list of strings that specify the attributes that are used to break down
costs in the margin summary reports for the billing group. For example, you can view your
costs by the Amazon Web Service name or the billing period.
- `"MaxResults"`: The maximum number of margin summary reports to retrieve.
- `"NextToken"`: The pagination token used on subsequent calls to get reports.
"""
function get_billing_group_cost_report(
Arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/get-billing-group-cost-report",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_billing_group_cost_report(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/get-billing-group-cost-report",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_account_associations()
list_account_associations(params::Dict{String,<:Any})
This is a paginated call to list linked accounts that are linked to the payer account for
the specified time period. If no information is provided, the current billing period is
used. The response will optionally include the billing group that's associated with the
linked account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period to get account associations.
- `"Filters"`: The filter on the account ID of the linked account, or any of the following:
MONITORED: linked accounts that are associated to billing groups. UNMONITORED: linked
accounts that aren't associated to billing groups. Billing Group Arn: linked accounts that
are associated to the provided billing group Arn.
- `"NextToken"`: The pagination token that's used on subsequent calls to retrieve
accounts.
"""
function list_account_associations(; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/list-account-associations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_account_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-account-associations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_billing_group_cost_reports()
list_billing_group_cost_reports(params::Dict{String,<:Any})
A paginated call to retrieve a summary report of actual Amazon Web Services charges and the
calculated Amazon Web Services charges based on the associated pricing plan of a billing
group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period for your report.
- `"Filters"`: A ListBillingGroupCostReportsFilter to specify billing groups to retrieve
reports from.
- `"MaxResults"`: The maximum number of reports to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent calls to get reports.
"""
function list_billing_group_cost_reports(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-billing-group-cost-reports";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_billing_group_cost_reports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-billing-group-cost-reports",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_billing_groups()
list_billing_groups(params::Dict{String,<:Any})
A paginated call to retrieve a list of billing groups for the given billing period. If you
don't provide a billing group, the current billing period is used.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period to get billing groups.
- `"Filters"`: A ListBillingGroupsFilter that specifies the billing group and pricing plan
to retrieve billing group information.
- `"MaxResults"`: The maximum number of billing groups to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent calls to get billing
groups.
"""
function list_billing_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/list-billing-groups";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_billing_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-billing-groups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_custom_line_item_versions(arn)
list_custom_line_item_versions(arn, params::Dict{String,<:Any})
A paginated call to get a list of all custom line item versions.
# Arguments
- `arn`: The Amazon Resource Name (ARN) for the custom line item.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: A ListCustomLineItemVersionsFilter that specifies the billing period range
in which the custom line item versions are applied.
- `"MaxResults"`: The maximum number of custom line item versions to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent calls to retrieve custom
line item versions.
"""
function list_custom_line_item_versions(
Arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-custom-line-item-versions",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_custom_line_item_versions(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-custom-line-item-versions",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_custom_line_items()
list_custom_line_items(params::Dict{String,<:Any})
A paginated call to get a list of all custom line items (FFLIs) for the given billing
period. If you don't provide a billing period, the current billing period is used.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period to get custom line items (FFLIs).
- `"Filters"`: A ListCustomLineItemsFilter that specifies the custom line item names and/or
billing group Amazon Resource Names (ARNs) to retrieve FFLI information.
- `"MaxResults"`: The maximum number of billing groups to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent calls to get custom line
items (FFLIs).
"""
function list_custom_line_items(; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/list-custom-line-items";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_custom_line_items(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-custom-line-items",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pricing_plans()
list_pricing_plans(params::Dict{String,<:Any})
A paginated call to get pricing plans for the given billing period. If you don't provide a
billing period, the current billing period is used.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period to get pricing plan.
- `"Filters"`: A ListPricingPlansFilter that specifies the Amazon Resource Name (ARNs) of
pricing plans to retrieve pricing plans information.
- `"MaxResults"`: The maximum number of pricing plans to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent call to get pricing plans.
"""
function list_pricing_plans(; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/list-pricing-plans";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pricing_plans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-pricing-plans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pricing_plans_associated_with_pricing_rule(pricing_rule_arn)
list_pricing_plans_associated_with_pricing_rule(pricing_rule_arn, params::Dict{String,<:Any})
A list of the pricing plans that are associated with a pricing rule.
# Arguments
- `pricing_rule_arn`: The pricing rule Amazon Resource Name (ARN) for which associations
will be listed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The pricing plan billing period for which associations will be
listed.
- `"MaxResults"`: The optional maximum number of pricing rule associations to retrieve.
- `"NextToken"`: The optional pagination token returned by a previous call.
"""
function list_pricing_plans_associated_with_pricing_rule(
PricingRuleArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-pricing-plans-associated-with-pricing-rule",
Dict{String,Any}("PricingRuleArn" => PricingRuleArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pricing_plans_associated_with_pricing_rule(
PricingRuleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/list-pricing-plans-associated-with-pricing-rule",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PricingRuleArn" => PricingRuleArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pricing_rules()
list_pricing_rules(params::Dict{String,<:Any})
Describes a pricing rule that can be associated to a pricing plan, or set of pricing
plans.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The preferred billing period to get the pricing plan.
- `"Filters"`: A DescribePricingRuleFilter that specifies the Amazon Resource Name (ARNs)
of pricing rules to retrieve pricing rules information.
- `"MaxResults"`: The maximum number of pricing rules to retrieve.
- `"NextToken"`: The pagination token that's used on subsequent call to get pricing rules.
"""
function list_pricing_rules(; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/list-pricing-rules";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pricing_rules(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-pricing-rules",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pricing_rules_associated_to_pricing_plan(pricing_plan_arn)
list_pricing_rules_associated_to_pricing_plan(pricing_plan_arn, params::Dict{String,<:Any})
Lists the pricing rules that are associated with a pricing plan.
# Arguments
- `pricing_plan_arn`: The Amazon Resource Name (ARN) of the pricing plan for which
associations are to be listed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The billing period for which the pricing rule associations are to be
listed.
- `"MaxResults"`: The optional maximum number of pricing rule associations to retrieve.
- `"NextToken"`: The optional pagination token returned by a previous call.
"""
function list_pricing_rules_associated_to_pricing_plan(
PricingPlanArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-pricing-rules-associated-to-pricing-plan",
Dict{String,Any}("PricingPlanArn" => PricingPlanArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pricing_rules_associated_to_pricing_plan(
PricingPlanArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/list-pricing-rules-associated-to-pricing-plan",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PricingPlanArn" => PricingPlanArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resources_associated_to_custom_line_item(arn)
list_resources_associated_to_custom_line_item(arn, params::Dict{String,<:Any})
List the resources that are associated to a custom line item.
# Arguments
- `arn`: The ARN of the custom line item for which the resource associations will be
listed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriod"`: The billing period for which the resource associations will be
listed.
- `"Filters"`: (Optional) A ListResourcesAssociatedToCustomLineItemFilter that can specify
the types of resources that should be retrieved.
- `"MaxResults"`: (Optional) The maximum number of resource associations to be retrieved.
- `"NextToken"`: (Optional) The pagination token that's returned by a previous request.
"""
function list_resources_associated_to_custom_line_item(
Arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-resources-associated-to-custom-line-item",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resources_associated_to_custom_line_item(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/list-resources-associated-to-custom-line-item",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
A list the tags for a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) that identifies the resource to list the
tags.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"GET",
"/tags/$(ResourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"GET",
"/tags/$(ResourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associates the specified tags to a resource with the specified resourceArn. If existing
tags on a resource are not specified in the request parameters, they are not changed.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to which to add tags.
- `tags`: The tags to add to the resource as a list of key-value pairs.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/tags/$(ResourceArn)",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"POST",
"/tags/$(ResourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Deletes specified tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to which to delete tags.
- `tag_keys`: The tags to delete from the resource as a list of key-value pairs.
"""
function untag_resource(
ResourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"DELETE",
"/tags/$(ResourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return billingconductor(
"DELETE",
"/tags/$(ResourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_billing_group(arn)
update_billing_group(arn, params::Dict{String,<:Any})
This updates an existing billing group.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the billing group being updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccountGrouping"`: Specifies if the billing group has automatic account association
(AutoAssociate) enabled.
- `"ComputationPreference"`: The preferences and settings that will be used to compute the
Amazon Web Services charges for a billing group.
- `"Description"`: A description of the billing group.
- `"Name"`: The name of the billing group. The names must be unique to each billing group.
- `"Status"`: The status of the billing group. Only one of the valid values can be used.
"""
function update_billing_group(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/update-billing-group",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_billing_group(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/update-billing-group",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_custom_line_item(arn)
update_custom_line_item(arn, params::Dict{String,<:Any})
Update an existing custom line item in the current or previous billing period.
# Arguments
- `arn`: The ARN of the custom line item to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BillingPeriodRange"`:
- `"ChargeDetails"`: A ListCustomLineItemChargeDetails containing the new charge details
for the custom line item.
- `"Description"`: The new line item description of the custom line item.
- `"Name"`: The new name for the custom line item.
"""
function update_custom_line_item(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"POST",
"/update-custom-line-item",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_custom_line_item(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"POST",
"/update-custom-line-item",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pricing_plan(arn)
update_pricing_plan(arn, params::Dict{String,<:Any})
This updates an existing pricing plan.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the pricing plan that you're updating.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the pricing plan.
- `"Name"`: The name of the pricing plan. The name must be unique to each pricing plan.
"""
function update_pricing_plan(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"PUT",
"/update-pricing-plan",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pricing_plan(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/update-pricing-plan",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pricing_rule(arn)
update_pricing_rule(arn, params::Dict{String,<:Any})
Updates an existing pricing rule.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the pricing rule to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The new description for the pricing rule.
- `"ModifierPercentage"`: The new modifier to show pricing plan rates as a percentage.
- `"Name"`: The new name of the pricing rule. The name must be unique to each pricing
rule.
- `"Tiering"`: The set of tiering configurations for the pricing rule.
- `"Type"`: The new pricing rule type.
"""
function update_pricing_rule(Arn; aws_config::AbstractAWSConfig=global_aws_config())
return billingconductor(
"PUT",
"/update-pricing-rule",
Dict{String,Any}("Arn" => Arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pricing_rule(
Arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return billingconductor(
"PUT",
"/update-pricing-rule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Arn" => Arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 17862 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: braket
using AWS.Compat
using AWS.UUIDs
"""
cancel_job(job_arn)
cancel_job(job_arn, params::Dict{String,<:Any})
Cancels an Amazon Braket job.
# Arguments
- `job_arn`: The ARN of the Amazon Braket job to cancel.
"""
function cancel_job(jobArn; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"PUT",
"/job/$(jobArn)/cancel";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_job(
jobArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"PUT",
"/job/$(jobArn)/cancel",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_quantum_task(client_token, quantum_task_arn)
cancel_quantum_task(client_token, quantum_task_arn, params::Dict{String,<:Any})
Cancels the specified task.
# Arguments
- `client_token`: The client token associated with the request.
- `quantum_task_arn`: The ARN of the task to cancel.
"""
function cancel_quantum_task(
clientToken, quantumTaskArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"PUT",
"/quantum-task/$(quantumTaskArn)/cancel",
Dict{String,Any}("clientToken" => clientToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_quantum_task(
clientToken,
quantumTaskArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"PUT",
"/quantum-task/$(quantumTaskArn)/cancel",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("clientToken" => clientToken), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_job(algorithm_specification, client_token, device_config, instance_config, job_name, output_data_config, role_arn)
create_job(algorithm_specification, client_token, device_config, instance_config, job_name, output_data_config, role_arn, params::Dict{String,<:Any})
Creates an Amazon Braket job.
# Arguments
- `algorithm_specification`: Definition of the Amazon Braket job to be created. Specifies
the container image the job uses and information about the Python scripts used for entry
and training.
- `client_token`: A unique token that guarantees that the call to this API is idempotent.
- `device_config`: The quantum processing unit (QPU) or simulator used to create an Amazon
Braket job.
- `instance_config`: Configuration of the resource instances to use while running the
hybrid job on Amazon Braket.
- `job_name`: The name of the Amazon Braket job.
- `output_data_config`: The path to the S3 location where you want to store job artifacts
and the encryption key used to store them.
- `role_arn`: The Amazon Resource Name (ARN) of an IAM role that Amazon Braket can assume
to perform tasks on behalf of a user. It can access user resources, run an Amazon Braket
job container on behalf of user, and output resources to the users' s3 buckets.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"associations"`: The list of Amazon Braket resources associated with the hybrid job.
- `"checkpointConfig"`: Information about the output locations for job checkpoint data.
- `"hyperParameters"`: Algorithm-specific parameters used by an Amazon Braket job that
influence the quality of the training job. The values are set with a string of JSON
key:value pairs, where the key is the name of the hyperparameter and the value is the value
of th hyperparameter.
- `"inputDataConfig"`: A list of parameters that specify the name and type of input data
and where it is located.
- `"stoppingCondition"`: The user-defined criteria that specifies when a job stops running.
- `"tags"`: A tag object that consists of a key and an optional value, used to manage
metadata for Amazon Braket resources.
"""
function create_job(
algorithmSpecification,
clientToken,
deviceConfig,
instanceConfig,
jobName,
outputDataConfig,
roleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"POST",
"/job",
Dict{String,Any}(
"algorithmSpecification" => algorithmSpecification,
"clientToken" => clientToken,
"deviceConfig" => deviceConfig,
"instanceConfig" => instanceConfig,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_job(
algorithmSpecification,
clientToken,
deviceConfig,
instanceConfig,
jobName,
outputDataConfig,
roleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"POST",
"/job",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"algorithmSpecification" => algorithmSpecification,
"clientToken" => clientToken,
"deviceConfig" => deviceConfig,
"instanceConfig" => instanceConfig,
"jobName" => jobName,
"outputDataConfig" => outputDataConfig,
"roleArn" => roleArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_quantum_task(action, client_token, device_arn, output_s3_bucket, output_s3_key_prefix, shots)
create_quantum_task(action, client_token, device_arn, output_s3_bucket, output_s3_key_prefix, shots, params::Dict{String,<:Any})
Creates a quantum task.
# Arguments
- `action`: The action associated with the task.
- `client_token`: The client token associated with the request.
- `device_arn`: The ARN of the device to run the task on.
- `output_s3_bucket`: The S3 bucket to store task result files in.
- `output_s3_key_prefix`: The key prefix for the location in the S3 bucket to store task
results in.
- `shots`: The number of shots to use for the task.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"associations"`: The list of Amazon Braket resources associated with the quantum task.
- `"deviceParameters"`: The parameters for the device to run the task on.
- `"jobToken"`: The token for an Amazon Braket job that associates it with the quantum task.
- `"tags"`: Tags to be added to the quantum task you're creating.
"""
function create_quantum_task(
action,
clientToken,
deviceArn,
outputS3Bucket,
outputS3KeyPrefix,
shots;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"POST",
"/quantum-task",
Dict{String,Any}(
"action" => action,
"clientToken" => clientToken,
"deviceArn" => deviceArn,
"outputS3Bucket" => outputS3Bucket,
"outputS3KeyPrefix" => outputS3KeyPrefix,
"shots" => shots,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_quantum_task(
action,
clientToken,
deviceArn,
outputS3Bucket,
outputS3KeyPrefix,
shots,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"POST",
"/quantum-task",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"action" => action,
"clientToken" => clientToken,
"deviceArn" => deviceArn,
"outputS3Bucket" => outputS3Bucket,
"outputS3KeyPrefix" => outputS3KeyPrefix,
"shots" => shots,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_device(device_arn)
get_device(device_arn, params::Dict{String,<:Any})
Retrieves the devices available in Amazon Braket. For backwards compatibility with older
versions of BraketSchemas, OpenQASM information is omitted from GetDevice API calls. To get
this information the user-agent needs to present a recent version of the BraketSchemas
(1.8.0 or later). The Braket SDK automatically reports this for you. If you do not see
OpenQASM results in the GetDevice response when using a Braket SDK, you may need to set
AWS_EXECUTION_ENV environment variable to configure user-agent. See the code examples
provided below for how to do this for the AWS CLI, Boto3, and the Go, Java, and
JavaScript/TypeScript SDKs.
# Arguments
- `device_arn`: The ARN of the device to retrieve.
"""
function get_device(deviceArn; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"GET",
"/device/$(deviceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_device(
deviceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"GET",
"/device/$(deviceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_job(job_arn)
get_job(job_arn, params::Dict{String,<:Any})
Retrieves the specified Amazon Braket job.
# Arguments
- `job_arn`: The ARN of the job to retrieve.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalAttributeNames"`: A list of attributes to return information for.
"""
function get_job(jobArn; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"GET", "/job/$(jobArn)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_job(
jobArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"GET",
"/job/$(jobArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_quantum_task(quantum_task_arn)
get_quantum_task(quantum_task_arn, params::Dict{String,<:Any})
Retrieves the specified quantum task.
# Arguments
- `quantum_task_arn`: The ARN of the task to retrieve.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"additionalAttributeNames"`: A list of attributes to return information for.
"""
function get_quantum_task(quantumTaskArn; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"GET",
"/quantum-task/$(quantumTaskArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_quantum_task(
quantumTaskArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"GET",
"/quantum-task/$(quantumTaskArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Shows the tags associated with this resource.
# Arguments
- `resource_arn`: Specify the resourceArn for the resource whose tags to display.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_devices(filters)
search_devices(filters, params::Dict{String,<:Any})
Searches for devices using the specified filters.
# Arguments
- `filters`: The filter values to use to search for a device.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned in the response. Use the
token returned from the previous request continue results where the previous request ended.
"""
function search_devices(filters; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"POST",
"/devices",
Dict{String,Any}("filters" => filters);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_devices(
filters, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"POST",
"/devices",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("filters" => filters), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_jobs(filters)
search_jobs(filters, params::Dict{String,<:Any})
Searches for Amazon Braket jobs that match the specified filter values.
# Arguments
- `filters`: The filter values to use when searching for a job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned in the response. Use the
token returned from the previous request to continue results where the previous request
ended.
"""
function search_jobs(filters; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"POST",
"/jobs",
Dict{String,Any}("filters" => filters);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_jobs(
filters, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"POST",
"/jobs",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("filters" => filters), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_quantum_tasks(filters)
search_quantum_tasks(filters, params::Dict{String,<:Any})
Searches for tasks that match the specified filter values.
# Arguments
- `filters`: Array of SearchQuantumTasksFilter objects.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Maximum number of results to return in the response.
- `"nextToken"`: A token used for pagination of results returned in the response. Use the
token returned from the previous request continue results where the previous request ended.
"""
function search_quantum_tasks(filters; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"POST",
"/quantum-tasks",
Dict{String,Any}("filters" => filters);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_quantum_tasks(
filters, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"POST",
"/quantum-tasks",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("filters" => filters), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Add a tag to the specified resource.
# Arguments
- `resource_arn`: Specify the resourceArn of the resource to which a tag will be added.
- `tags`: Specify the tags to add to the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return braket(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Remove tags from a resource.
# Arguments
- `resource_arn`: Specify the resourceArn for the resource from which to remove the tags.
- `tag_keys`: Specify the keys for the tags to remove from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return braket(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return braket(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 41138 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: budgets
using AWS.Compat
using AWS.UUIDs
"""
create_budget(account_id, budget)
create_budget(account_id, budget, params::Dict{String,<:Any})
Creates a budget and, if included, notifications and subscribers. Only one of BudgetLimit
or PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that
matches your case. The Request Syntax section shows the BudgetLimit syntax. For
PlannedBudgetLimits, see the Examples section.
# Arguments
- `account_id`: The accountId that is associated with the budget.
- `budget`: The budget object that you want to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NotificationsWithSubscribers"`: A notification that you want to associate with a
budget. A budget can have up to five notifications, and each notification can have one SNS
subscriber and up to 10 email subscribers. If you include notifications and subscribers in
your CreateBudget call, Amazon Web Services creates the notifications and subscribers for
you.
- `"ResourceTags"`: An optional list of tags to associate with the specified budget. Each
tag consists of a key and a value, and each key must be unique for the resource.
"""
function create_budget(AccountId, Budget; aws_config::AbstractAWSConfig=global_aws_config())
return budgets(
"CreateBudget",
Dict{String,Any}("AccountId" => AccountId, "Budget" => Budget);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_budget(
AccountId,
Budget,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "Budget" => Budget),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_budget_action(account_id, action_threshold, action_type, approval_model, budget_name, definition, execution_role_arn, notification_type, subscribers)
create_budget_action(account_id, action_threshold, action_type, approval_model, budget_name, definition, execution_role_arn, notification_type, subscribers, params::Dict{String,<:Any})
Creates a budget action.
# Arguments
- `account_id`:
- `action_threshold`:
- `action_type`: The type of action. This defines the type of tasks that can be carried
out by this action. This field also determines the format for definition.
- `approval_model`: This specifies if the action needs manual or automatic approval.
- `budget_name`:
- `definition`:
- `execution_role_arn`: The role passed for action execution and reversion. Roles and
actions must be in the same account.
- `notification_type`:
- `subscribers`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ResourceTags"`: An optional list of tags to associate with the specified budget action.
Each tag consists of a key and a value, and each key must be unique for the resource.
"""
function create_budget_action(
AccountId,
ActionThreshold,
ActionType,
ApprovalModel,
BudgetName,
Definition,
ExecutionRoleArn,
NotificationType,
Subscribers;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateBudgetAction",
Dict{String,Any}(
"AccountId" => AccountId,
"ActionThreshold" => ActionThreshold,
"ActionType" => ActionType,
"ApprovalModel" => ApprovalModel,
"BudgetName" => BudgetName,
"Definition" => Definition,
"ExecutionRoleArn" => ExecutionRoleArn,
"NotificationType" => NotificationType,
"Subscribers" => Subscribers,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_budget_action(
AccountId,
ActionThreshold,
ActionType,
ApprovalModel,
BudgetName,
Definition,
ExecutionRoleArn,
NotificationType,
Subscribers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateBudgetAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionThreshold" => ActionThreshold,
"ActionType" => ActionType,
"ApprovalModel" => ApprovalModel,
"BudgetName" => BudgetName,
"Definition" => Definition,
"ExecutionRoleArn" => ExecutionRoleArn,
"NotificationType" => NotificationType,
"Subscribers" => Subscribers,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_notification(account_id, budget_name, notification, subscribers)
create_notification(account_id, budget_name, notification, subscribers, params::Dict{String,<:Any})
Creates a notification. You must create the budget before you create the associated
notification.
# Arguments
- `account_id`: The accountId that is associated with the budget that you want to create a
notification for.
- `budget_name`: The name of the budget that you want Amazon Web Services to notify you
about. Budget names must be unique within an account.
- `notification`: The notification that you want to create.
- `subscribers`: A list of subscribers that you want to associate with the notification.
Each notification can have one SNS subscriber and up to 10 email subscribers.
"""
function create_notification(
AccountId,
BudgetName,
Notification,
Subscribers;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateNotification",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscribers" => Subscribers,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_notification(
AccountId,
BudgetName,
Notification,
Subscribers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateNotification",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscribers" => Subscribers,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_subscriber(account_id, budget_name, notification, subscriber)
create_subscriber(account_id, budget_name, notification, subscriber, params::Dict{String,<:Any})
Creates a subscriber. You must create the associated budget and notification before you
create the subscriber.
# Arguments
- `account_id`: The accountId that is associated with the budget that you want to create a
subscriber for.
- `budget_name`: The name of the budget that you want to subscribe to. Budget names must be
unique within an account.
- `notification`: The notification that you want to create a subscriber for.
- `subscriber`: The subscriber that you want to associate with a budget notification.
"""
function create_subscriber(
AccountId,
BudgetName,
Notification,
Subscriber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateSubscriber",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscriber" => Subscriber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_subscriber(
AccountId,
BudgetName,
Notification,
Subscriber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"CreateSubscriber",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscriber" => Subscriber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_budget(account_id, budget_name)
delete_budget(account_id, budget_name, params::Dict{String,<:Any})
Deletes a budget. You can delete your budget at any time. Deleting a budget also deletes
the notifications and subscribers that are associated with that budget.
# Arguments
- `account_id`: The accountId that is associated with the budget that you want to delete.
- `budget_name`: The name of the budget that you want to delete.
"""
function delete_budget(
AccountId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DeleteBudget",
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_budget(
AccountId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DeleteBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_budget_action(account_id, action_id, budget_name)
delete_budget_action(account_id, action_id, budget_name, params::Dict{String,<:Any})
Deletes a budget action.
# Arguments
- `account_id`:
- `action_id`: A system-generated universally unique identifier (UUID) for the action.
- `budget_name`:
"""
function delete_budget_action(
AccountId, ActionId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DeleteBudgetAction",
Dict{String,Any}(
"AccountId" => AccountId, "ActionId" => ActionId, "BudgetName" => BudgetName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_budget_action(
AccountId,
ActionId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DeleteBudgetAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_notification(account_id, budget_name, notification)
delete_notification(account_id, budget_name, notification, params::Dict{String,<:Any})
Deletes a notification. Deleting a notification also deletes the subscribers that are
associated with the notification.
# Arguments
- `account_id`: The accountId that is associated with the budget whose notification you
want to delete.
- `budget_name`: The name of the budget whose notification you want to delete.
- `notification`: The notification that you want to delete.
"""
function delete_notification(
AccountId, BudgetName, Notification; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DeleteNotification",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_notification(
AccountId,
BudgetName,
Notification,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DeleteNotification",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_subscriber(account_id, budget_name, notification, subscriber)
delete_subscriber(account_id, budget_name, notification, subscriber, params::Dict{String,<:Any})
Deletes a subscriber. Deleting the last subscriber to a notification also deletes the
notification.
# Arguments
- `account_id`: The accountId that is associated with the budget whose subscriber you want
to delete.
- `budget_name`: The name of the budget whose subscriber you want to delete.
- `notification`: The notification whose subscriber you want to delete.
- `subscriber`: The subscriber that you want to delete.
"""
function delete_subscriber(
AccountId,
BudgetName,
Notification,
Subscriber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DeleteSubscriber",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscriber" => Subscriber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_subscriber(
AccountId,
BudgetName,
Notification,
Subscriber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DeleteSubscriber",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
"Subscriber" => Subscriber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget(account_id, budget_name)
describe_budget(account_id, budget_name, params::Dict{String,<:Any})
Describes a budget. The Request Syntax section shows the BudgetLimit syntax. For
PlannedBudgetLimits, see the Examples section.
# Arguments
- `account_id`: The accountId that is associated with the budget that you want a
description of.
- `budget_name`: The name of the budget that you want a description of.
"""
function describe_budget(
AccountId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudget",
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget(
AccountId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_action(account_id, action_id, budget_name)
describe_budget_action(account_id, action_id, budget_name, params::Dict{String,<:Any})
Describes a budget action detail.
# Arguments
- `account_id`:
- `action_id`: A system-generated universally unique identifier (UUID) for the action.
- `budget_name`:
"""
function describe_budget_action(
AccountId, ActionId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetAction",
Dict{String,Any}(
"AccountId" => AccountId, "ActionId" => ActionId, "BudgetName" => BudgetName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_action(
AccountId,
ActionId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_action_histories(account_id, action_id, budget_name)
describe_budget_action_histories(account_id, action_id, budget_name, params::Dict{String,<:Any})
Describes a budget action history detail.
# Arguments
- `account_id`:
- `action_id`: A system-generated universally unique identifier (UUID) for the action.
- `budget_name`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`:
- `"NextToken"`:
- `"TimePeriod"`:
"""
function describe_budget_action_histories(
AccountId, ActionId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetActionHistories",
Dict{String,Any}(
"AccountId" => AccountId, "ActionId" => ActionId, "BudgetName" => BudgetName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_action_histories(
AccountId,
ActionId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetActionHistories",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_actions_for_account(account_id)
describe_budget_actions_for_account(account_id, params::Dict{String,<:Any})
Describes all of the budget actions for an account.
# Arguments
- `account_id`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`:
- `"NextToken"`:
"""
function describe_budget_actions_for_account(
AccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetActionsForAccount",
Dict{String,Any}("AccountId" => AccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_actions_for_account(
AccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetActionsForAccount",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AccountId" => AccountId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_actions_for_budget(account_id, budget_name)
describe_budget_actions_for_budget(account_id, budget_name, params::Dict{String,<:Any})
Describes all of the budget actions for a budget.
# Arguments
- `account_id`:
- `budget_name`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`:
- `"NextToken"`:
"""
function describe_budget_actions_for_budget(
AccountId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetActionsForBudget",
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_actions_for_budget(
AccountId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetActionsForBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_notifications_for_account(account_id)
describe_budget_notifications_for_account(account_id, params::Dict{String,<:Any})
Lists the budget names and notifications that are associated with an account.
# Arguments
- `account_id`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: An integer that represents how many budgets a paginated response
contains. The default is 50.
- `"NextToken"`:
"""
function describe_budget_notifications_for_account(
AccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetNotificationsForAccount",
Dict{String,Any}("AccountId" => AccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_notifications_for_account(
AccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetNotificationsForAccount",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AccountId" => AccountId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budget_performance_history(account_id, budget_name)
describe_budget_performance_history(account_id, budget_name, params::Dict{String,<:Any})
Describes the history for DAILY, MONTHLY, and QUARTERLY budgets. Budget history isn't
available for ANNUAL budgets.
# Arguments
- `account_id`:
- `budget_name`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`:
- `"NextToken"`:
- `"TimePeriod"`: Retrieves how often the budget went into an ALARM state for the specified
time period.
"""
function describe_budget_performance_history(
AccountId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeBudgetPerformanceHistory",
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budget_performance_history(
AccountId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgetPerformanceHistory",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_budgets(account_id)
describe_budgets(account_id, params::Dict{String,<:Any})
Lists the budgets that are associated with an account. The Request Syntax section shows
the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section.
# Arguments
- `account_id`: The accountId that is associated with the budgets that you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: An integer that represents how many budgets a paginated response
contains. The default is 100.
- `"NextToken"`: The pagination token that you include in your request to indicate the next
set of results that you want to retrieve.
"""
function describe_budgets(AccountId; aws_config::AbstractAWSConfig=global_aws_config())
return budgets(
"DescribeBudgets",
Dict{String,Any}("AccountId" => AccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_budgets(
AccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeBudgets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AccountId" => AccountId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_notifications_for_budget(account_id, budget_name)
describe_notifications_for_budget(account_id, budget_name, params::Dict{String,<:Any})
Lists the notifications that are associated with a budget.
# Arguments
- `account_id`: The accountId that is associated with the budget whose notifications you
want descriptions of.
- `budget_name`: The name of the budget whose notifications you want descriptions of.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: An optional integer that represents how many entries a paginated response
contains.
- `"NextToken"`: The pagination token that you include in your request to indicate the next
set of results that you want to retrieve.
"""
function describe_notifications_for_budget(
AccountId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeNotificationsForBudget",
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_notifications_for_budget(
AccountId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeNotificationsForBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "BudgetName" => BudgetName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_subscribers_for_notification(account_id, budget_name, notification)
describe_subscribers_for_notification(account_id, budget_name, notification, params::Dict{String,<:Any})
Lists the subscribers that are associated with a notification.
# Arguments
- `account_id`: The accountId that is associated with the budget whose subscribers you want
descriptions of.
- `budget_name`: The name of the budget whose subscribers you want descriptions of.
- `notification`: The notification whose subscribers you want to list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: An optional integer that represents how many entries a paginated response
contains.
- `"NextToken"`: The pagination token that you include in your request to indicate the next
set of results that you want to retrieve.
"""
function describe_subscribers_for_notification(
AccountId, BudgetName, Notification; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"DescribeSubscribersForNotification",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_subscribers_for_notification(
AccountId,
BudgetName,
Notification,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"DescribeSubscribersForNotification",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"Notification" => Notification,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
execute_budget_action(account_id, action_id, budget_name, execution_type)
execute_budget_action(account_id, action_id, budget_name, execution_type, params::Dict{String,<:Any})
Executes a budget action.
# Arguments
- `account_id`:
- `action_id`: A system-generated universally unique identifier (UUID) for the action.
- `budget_name`:
- `execution_type`: The type of execution.
"""
function execute_budget_action(
AccountId,
ActionId,
BudgetName,
ExecutionType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"ExecuteBudgetAction",
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
"ExecutionType" => ExecutionType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function execute_budget_action(
AccountId,
ActionId,
BudgetName,
ExecutionType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"ExecuteBudgetAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
"ExecutionType" => ExecutionType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists tags associated with a budget or budget action resource.
# Arguments
- `resource_arn`: The unique identifier for the resource.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, resource_tags)
tag_resource(resource_arn, resource_tags, params::Dict{String,<:Any})
Creates tags for a budget or budget action resource.
# Arguments
- `resource_arn`: The unique identifier for the resource.
- `resource_tags`: The tags associated with the resource.
"""
function tag_resource(
ResourceARN, ResourceTags; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "ResourceTags" => ResourceTags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
ResourceTags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceARN" => ResourceARN, "ResourceTags" => ResourceTags
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, resource_tag_keys)
untag_resource(resource_arn, resource_tag_keys, params::Dict{String,<:Any})
Deletes tags associated with a budget or budget action resource.
# Arguments
- `resource_arn`: The unique identifier for the resource.
- `resource_tag_keys`: The key that's associated with the tag.
"""
function untag_resource(
ResourceARN, ResourceTagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"UntagResource",
Dict{String,Any}(
"ResourceARN" => ResourceARN, "ResourceTagKeys" => ResourceTagKeys
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
ResourceTagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceARN" => ResourceARN, "ResourceTagKeys" => ResourceTagKeys
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_budget(account_id, new_budget)
update_budget(account_id, new_budget, params::Dict{String,<:Any})
Updates a budget. You can change every part of a budget except for the budgetName and the
calculatedSpend. When you modify a budget, the calculatedSpend drops to zero until Amazon
Web Services has new usage data to use for forecasting. Only one of BudgetLimit or
PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that matches
your case. The Request Syntax section shows the BudgetLimit syntax. For
PlannedBudgetLimits, see the Examples section.
# Arguments
- `account_id`: The accountId that is associated with the budget that you want to update.
- `new_budget`: The budget that you want to update your budget to.
"""
function update_budget(
AccountId, NewBudget; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"UpdateBudget",
Dict{String,Any}("AccountId" => AccountId, "NewBudget" => NewBudget);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_budget(
AccountId,
NewBudget,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateBudget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AccountId" => AccountId, "NewBudget" => NewBudget),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_budget_action(account_id, action_id, budget_name)
update_budget_action(account_id, action_id, budget_name, params::Dict{String,<:Any})
Updates a budget action.
# Arguments
- `account_id`:
- `action_id`: A system-generated universally unique identifier (UUID) for the action.
- `budget_name`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ActionThreshold"`:
- `"ApprovalModel"`: This specifies if the action needs manual or automatic approval.
- `"Definition"`:
- `"ExecutionRoleArn"`: The role passed for action execution and reversion. Roles and
actions must be in the same account.
- `"NotificationType"`:
- `"Subscribers"`:
"""
function update_budget_action(
AccountId, ActionId, BudgetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return budgets(
"UpdateBudgetAction",
Dict{String,Any}(
"AccountId" => AccountId, "ActionId" => ActionId, "BudgetName" => BudgetName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_budget_action(
AccountId,
ActionId,
BudgetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateBudgetAction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"ActionId" => ActionId,
"BudgetName" => BudgetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_notification(account_id, budget_name, new_notification, old_notification)
update_notification(account_id, budget_name, new_notification, old_notification, params::Dict{String,<:Any})
Updates a notification.
# Arguments
- `account_id`: The accountId that is associated with the budget whose notification you
want to update.
- `budget_name`: The name of the budget whose notification you want to update.
- `new_notification`: The updated notification to be associated with a budget.
- `old_notification`: The previous notification that is associated with a budget.
"""
function update_notification(
AccountId,
BudgetName,
NewNotification,
OldNotification;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateNotification",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"NewNotification" => NewNotification,
"OldNotification" => OldNotification,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_notification(
AccountId,
BudgetName,
NewNotification,
OldNotification,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateNotification",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"NewNotification" => NewNotification,
"OldNotification" => OldNotification,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_subscriber(account_id, budget_name, new_subscriber, notification, old_subscriber)
update_subscriber(account_id, budget_name, new_subscriber, notification, old_subscriber, params::Dict{String,<:Any})
Updates a subscriber.
# Arguments
- `account_id`: The accountId that is associated with the budget whose subscriber you want
to update.
- `budget_name`: The name of the budget whose subscriber you want to update.
- `new_subscriber`: The updated subscriber that is associated with a budget notification.
- `notification`: The notification whose subscriber you want to update.
- `old_subscriber`: The previous subscriber that is associated with a budget notification.
"""
function update_subscriber(
AccountId,
BudgetName,
NewSubscriber,
Notification,
OldSubscriber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateSubscriber",
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"NewSubscriber" => NewSubscriber,
"Notification" => Notification,
"OldSubscriber" => OldSubscriber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_subscriber(
AccountId,
BudgetName,
NewSubscriber,
Notification,
OldSubscriber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return budgets(
"UpdateSubscriber",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccountId" => AccountId,
"BudgetName" => BudgetName,
"NewSubscriber" => NewSubscriber,
"Notification" => Notification,
"OldSubscriber" => OldSubscriber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 41850 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chatbot
using AWS.Compat
using AWS.UUIDs
"""
create_chime_webhook_configuration(configuration_name, iam_role_arn, sns_topic_arns, webhook_description, webhook_url)
create_chime_webhook_configuration(configuration_name, iam_role_arn, sns_topic_arns, webhook_description, webhook_url, params::Dict{String,<:Any})
Creates Chime Webhook Configuration
# Arguments
- `configuration_name`: The name of the configuration.
- `iam_role_arn`: This is a user-defined role that AWS Chatbot will assume. This is not the
service-linked role. For more information, see IAM Policies for AWS Chatbot.
- `sns_topic_arns`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `webhook_description`: Description of the webhook. Recommend using the convention
`RoomName/WebhookName`. See Chime setup tutorial for more details:
https://docs.aws.amazon.com/chatbot/latest/adminguide/chime-setup.html.
- `webhook_url`: URL for the Chime webhook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"Tags"`: A list of tags to apply to the configuration.
"""
function create_chime_webhook_configuration(
ConfigurationName,
IamRoleArn,
SnsTopicArns,
WebhookDescription,
WebhookUrl;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-chime-webhook-configuration",
Dict{String,Any}(
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"SnsTopicArns" => SnsTopicArns,
"WebhookDescription" => WebhookDescription,
"WebhookUrl" => WebhookUrl,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_chime_webhook_configuration(
ConfigurationName,
IamRoleArn,
SnsTopicArns,
WebhookDescription,
WebhookUrl,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-chime-webhook-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"SnsTopicArns" => SnsTopicArns,
"WebhookDescription" => WebhookDescription,
"WebhookUrl" => WebhookUrl,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_microsoft_teams_channel_configuration(channel_id, configuration_name, iam_role_arn, team_id, tenant_id)
create_microsoft_teams_channel_configuration(channel_id, configuration_name, iam_role_arn, team_id, tenant_id, params::Dict{String,<:Any})
Creates MS Teams Channel Configuration
# Arguments
- `channel_id`: The ID of the Microsoft Teams channel.
- `configuration_name`: The name of the configuration.
- `iam_role_arn`: The ARN of the IAM role that defines the permissions for AWS Chatbot.
This is a user-defined role that AWS Chatbot will assume. This is not the service-linked
role. For more information, see IAM Policies for AWS Chatbot.
- `team_id`: The ID of the Microsoft Team authorized with AWS Chatbot. To get the team ID,
you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot
console. Then you can copy and paste the team ID from the console. For more details, see
steps 1-4 in Get started with Microsoft Teams in the AWS Chatbot Administrator Guide.
- `tenant_id`: The ID of the Microsoft Teams tenant.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChannelName"`: The name of the Microsoft Teams channel.
- `"GuardrailPolicyArns"`: The list of IAM policy ARNs that are applied as channel
guardrails. The AWS managed 'AdministratorAccess' policy is applied by default if this is
not set.
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"SnsTopicArns"`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `"Tags"`: A list of tags to apply to the configuration.
- `"TeamName"`: The name of the Microsoft Teams Team.
- `"UserAuthorizationRequired"`: Enables use of a user role requirement in your chat
configuration.
"""
function create_microsoft_teams_channel_configuration(
ChannelId,
ConfigurationName,
IamRoleArn,
TeamId,
TenantId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-ms-teams-channel-configuration",
Dict{String,Any}(
"ChannelId" => ChannelId,
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"TeamId" => TeamId,
"TenantId" => TenantId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_microsoft_teams_channel_configuration(
ChannelId,
ConfigurationName,
IamRoleArn,
TeamId,
TenantId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-ms-teams-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChannelId" => ChannelId,
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"TeamId" => TeamId,
"TenantId" => TenantId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_slack_channel_configuration(configuration_name, iam_role_arn, slack_channel_id, slack_team_id)
create_slack_channel_configuration(configuration_name, iam_role_arn, slack_channel_id, slack_team_id, params::Dict{String,<:Any})
Creates Slack Channel Configuration
# Arguments
- `configuration_name`: The name of the configuration.
- `iam_role_arn`: The ARN of the IAM role that defines the permissions for AWS Chatbot.
This is a user-defined role that AWS Chatbot will assume. This is not the service-linked
role. For more information, see IAM Policies for AWS Chatbot.
- `slack_channel_id`: The ID of the Slack channel. To get the ID, open Slack, right click
on the channel name in the left pane, then choose Copy Link. The channel ID is the
9-character string at the end of the URL. For example, ABCBBLZZZ.
- `slack_team_id`: The ID of the Slack workspace authorized with AWS Chatbot.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"GuardrailPolicyArns"`: The list of IAM policy ARNs that are applied as channel
guardrails. The AWS managed 'AdministratorAccess' policy is applied by default if this is
not set.
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"SlackChannelName"`: The name of the Slack Channel.
- `"SnsTopicArns"`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `"Tags"`: A list of tags to apply to the configuration.
- `"UserAuthorizationRequired"`: Enables use of a user role requirement in your chat
configuration.
"""
function create_slack_channel_configuration(
ConfigurationName,
IamRoleArn,
SlackChannelId,
SlackTeamId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-slack-channel-configuration",
Dict{String,Any}(
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"SlackChannelId" => SlackChannelId,
"SlackTeamId" => SlackTeamId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_slack_channel_configuration(
ConfigurationName,
IamRoleArn,
SlackChannelId,
SlackTeamId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/create-slack-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConfigurationName" => ConfigurationName,
"IamRoleArn" => IamRoleArn,
"SlackChannelId" => SlackChannelId,
"SlackTeamId" => SlackTeamId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_chime_webhook_configuration(chat_configuration_arn)
delete_chime_webhook_configuration(chat_configuration_arn, params::Dict{String,<:Any})
Deletes a Chime Webhook Configuration
# Arguments
- `chat_configuration_arn`: The ARN of the ChimeWebhookConfiguration to delete.
"""
function delete_chime_webhook_configuration(
ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-chime-webhook-configuration",
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_chime_webhook_configuration(
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-chime-webhook-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_microsoft_teams_channel_configuration(chat_configuration_arn)
delete_microsoft_teams_channel_configuration(chat_configuration_arn, params::Dict{String,<:Any})
Deletes MS Teams Channel Configuration
# Arguments
- `chat_configuration_arn`: The ARN of the MicrosoftTeamsChannelConfiguration to delete.
"""
function delete_microsoft_teams_channel_configuration(
ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-ms-teams-channel-configuration",
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_microsoft_teams_channel_configuration(
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-ms-teams-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_microsoft_teams_configured_team(team_id)
delete_microsoft_teams_configured_team(team_id, params::Dict{String,<:Any})
Deletes the Microsoft Teams team authorization allowing for channels to be configured in
that Microsoft Teams team. Note that the Microsoft Teams team must have no channels
configured to remove it.
# Arguments
- `team_id`: The ID of the Microsoft Team authorized with AWS Chatbot. To get the team ID,
you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot
console. Then you can copy and paste the team ID from the console. For more details, see
steps 1-4 in Get started with Microsoft Teams in the AWS Chatbot Administrator Guide.
"""
function delete_microsoft_teams_configured_team(
TeamId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-ms-teams-configured-teams",
Dict{String,Any}("TeamId" => TeamId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_microsoft_teams_configured_team(
TeamId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-ms-teams-configured-teams",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("TeamId" => TeamId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_microsoft_teams_user_identity(chat_configuration_arn, user_id)
delete_microsoft_teams_user_identity(chat_configuration_arn, user_id, params::Dict{String,<:Any})
Deletes a Teams user identity
# Arguments
- `chat_configuration_arn`: The ARN of the MicrosoftTeamsChannelConfiguration associated
with the user identity to delete.
- `user_id`: Id from Microsoft Teams for user.
"""
function delete_microsoft_teams_user_identity(
ChatConfigurationArn, UserId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-ms-teams-user-identity",
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn, "UserId" => UserId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_microsoft_teams_user_identity(
ChatConfigurationArn,
UserId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-ms-teams-user-identity",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn, "UserId" => UserId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_slack_channel_configuration(chat_configuration_arn)
delete_slack_channel_configuration(chat_configuration_arn, params::Dict{String,<:Any})
Deletes Slack Channel Configuration
# Arguments
- `chat_configuration_arn`: The ARN of the SlackChannelConfiguration to delete.
"""
function delete_slack_channel_configuration(
ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-slack-channel-configuration",
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_slack_channel_configuration(
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-slack-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_slack_user_identity(chat_configuration_arn, slack_team_id, slack_user_id)
delete_slack_user_identity(chat_configuration_arn, slack_team_id, slack_user_id, params::Dict{String,<:Any})
Deletes a Slack user identity
# Arguments
- `chat_configuration_arn`: The ARN of the SlackChannelConfiguration associated with the
user identity to delete.
- `slack_team_id`: The ID of the Slack workspace authorized with AWS Chatbot.
- `slack_user_id`: The ID of the user in Slack.
"""
function delete_slack_user_identity(
ChatConfigurationArn,
SlackTeamId,
SlackUserId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-slack-user-identity",
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn,
"SlackTeamId" => SlackTeamId,
"SlackUserId" => SlackUserId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_slack_user_identity(
ChatConfigurationArn,
SlackTeamId,
SlackUserId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-slack-user-identity",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn,
"SlackTeamId" => SlackTeamId,
"SlackUserId" => SlackUserId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_slack_workspace_authorization(slack_team_id)
delete_slack_workspace_authorization(slack_team_id, params::Dict{String,<:Any})
Deletes the Slack workspace authorization that allows channels to be configured in that
workspace. This requires all configured channels in the workspace to be deleted.
# Arguments
- `slack_team_id`: The ID of the Slack workspace authorized with AWS Chatbot.
"""
function delete_slack_workspace_authorization(
SlackTeamId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/delete-slack-workspace-authorization",
Dict{String,Any}("SlackTeamId" => SlackTeamId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_slack_workspace_authorization(
SlackTeamId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/delete-slack-workspace-authorization",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SlackTeamId" => SlackTeamId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_chime_webhook_configurations()
describe_chime_webhook_configurations(params::Dict{String,<:Any})
Lists Chime Webhook Configurations optionally filtered by ChatConfigurationArn
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChatConfigurationArn"`: An optional ARN of a ChimeWebhookConfiguration to describe.
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function describe_chime_webhook_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-chime-webhook-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_chime_webhook_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-chime-webhook-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_slack_channel_configurations()
describe_slack_channel_configurations(params::Dict{String,<:Any})
Lists Slack Channel Configurations optionally filtered by ChatConfigurationArn
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChatConfigurationArn"`: An optional ARN of a SlackChannelConfiguration to describe.
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function describe_slack_channel_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-slack-channel-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_slack_channel_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-slack-channel-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_slack_user_identities()
describe_slack_user_identities(params::Dict{String,<:Any})
Lists all Slack user identities with a mapped role.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChatConfigurationArn"`: The ARN of the SlackChannelConfiguration associated with the
user identities to describe.
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function describe_slack_user_identities(; aws_config::AbstractAWSConfig=global_aws_config())
return chatbot(
"POST",
"/describe-slack-user-identities";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_slack_user_identities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-slack-user-identities",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_slack_workspaces()
describe_slack_workspaces(params::Dict{String,<:Any})
Lists all authorized Slack Workspaces for AWS Account
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function describe_slack_workspaces(; aws_config::AbstractAWSConfig=global_aws_config())
return chatbot(
"POST",
"/describe-slack-workspaces";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_slack_workspaces(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/describe-slack-workspaces",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account_preferences()
get_account_preferences(params::Dict{String,<:Any})
Get Chatbot account level preferences
"""
function get_account_preferences(; aws_config::AbstractAWSConfig=global_aws_config())
return chatbot(
"POST",
"/get-account-preferences";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_account_preferences(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/get-account-preferences",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_microsoft_teams_channel_configuration(chat_configuration_arn)
get_microsoft_teams_channel_configuration(chat_configuration_arn, params::Dict{String,<:Any})
Get a single MS Teams Channel Configurations
# Arguments
- `chat_configuration_arn`: The ARN of the MicrosoftTeamsChannelConfiguration to retrieve.
"""
function get_microsoft_teams_channel_configuration(
ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/get-ms-teams-channel-configuration",
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_microsoft_teams_channel_configuration(
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/get-ms-teams-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_microsoft_teams_channel_configurations()
list_microsoft_teams_channel_configurations(params::Dict{String,<:Any})
Lists MS Teams Channel Configurations optionally filtered by TeamId
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
- `"TeamId"`: The ID of the Microsoft Team authorized with AWS Chatbot. To get the team ID,
you must perform the initial authorization flow with Microsoft Teams in the AWS Chatbot
console. Then you can copy and paste the team ID from the console. For more details, see
steps 1-4 in Get started with Microsoft Teams in the AWS Chatbot Administrator Guide.
"""
function list_microsoft_teams_channel_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-channel-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_microsoft_teams_channel_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-channel-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_microsoft_teams_configured_teams()
list_microsoft_teams_configured_teams(params::Dict{String,<:Any})
Lists all authorized MS teams for AWS Account
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function list_microsoft_teams_configured_teams(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-configured-teams";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_microsoft_teams_configured_teams(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-configured-teams",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_microsoft_teams_user_identities()
list_microsoft_teams_user_identities(params::Dict{String,<:Any})
Lists all Microsoft Teams user identities with a mapped role.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChatConfigurationArn"`: The ARN of the MicrosoftTeamsChannelConfiguration associated
with the user identities to list.
- `"MaxResults"`: The maximum number of results to include in the response. If more results
exist than the specified MaxResults value, a token is included in the response so that the
remaining results can be retrieved.
- `"NextToken"`: An optional token returned from a prior request. Use this token for
pagination of results from this action. If this parameter is specified, the response
includes only results beyond the token, up to the value specified by MaxResults.
"""
function list_microsoft_teams_user_identities(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-user-identities";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_microsoft_teams_user_identities(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-ms-teams-user-identities",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Retrieves the list of tags applied to a configuration.
# Arguments
- `resource_arn`: The ARN of the configuration.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/list-tags-for-resource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/list-tags-for-resource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Applies the supplied tags to a configuration.
# Arguments
- `resource_arn`: The ARN of the configuration.
- `tags`: A list of tags to apply to the configuration.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chatbot(
"POST",
"/tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the supplied tags from a configuration
# Arguments
- `resource_arn`: The ARN of the configuration.
- `tag_keys`: A list of tag keys to remove from the configuration.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_account_preferences()
update_account_preferences(params::Dict{String,<:Any})
Update Chatbot account level preferences
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"TrainingDataCollectionEnabled"`: Turns on training data collection. This helps improve
the AWS Chatbot experience by allowing AWS Chatbot to store and use your customer
information, such as AWS Chatbot configurations, notifications, user inputs, AWS Chatbot
generated responses, and interaction data. This data helps us to continuously improve and
develop Artificial Intelligence (AI) technologies. Your data is not shared with any third
parties and is protected using sophisticated controls to prevent unauthorized access and
misuse. AWS Chatbot does not store or use interactions in chat channels with Amazon Q for
training AWS Chatbot’s AI technologies.
- `"UserAuthorizationRequired"`: Enables use of a user role requirement in your chat
configuration.
"""
function update_account_preferences(; aws_config::AbstractAWSConfig=global_aws_config())
return chatbot(
"POST",
"/update-account-preferences";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_account_preferences(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/update-account-preferences",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_chime_webhook_configuration(chat_configuration_arn)
update_chime_webhook_configuration(chat_configuration_arn, params::Dict{String,<:Any})
Updates a Chime Webhook Configuration
# Arguments
- `chat_configuration_arn`: The ARN of the ChimeWebhookConfiguration to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IamRoleArn"`: The ARN of the IAM role that defines the permissions for AWS Chatbot.
This is a user-defined role that AWS Chatbot will assume. This is not the service-linked
role. For more information, see IAM Policies for AWS Chatbot.
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"SnsTopicArns"`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `"WebhookDescription"`: Description of the webhook. Recommend using the convention
`RoomName/WebhookName`. See Chime setup tutorial for more details:
https://docs.aws.amazon.com/chatbot/latest/adminguide/chime-setup.html.
- `"WebhookUrl"`: URL for the Chime webhook.
"""
function update_chime_webhook_configuration(
ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/update-chime-webhook-configuration",
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_chime_webhook_configuration(
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/update-chime-webhook-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChatConfigurationArn" => ChatConfigurationArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_microsoft_teams_channel_configuration(channel_id, chat_configuration_arn)
update_microsoft_teams_channel_configuration(channel_id, chat_configuration_arn, params::Dict{String,<:Any})
Updates MS Teams Channel Configuration
# Arguments
- `channel_id`: The ID of the Microsoft Teams channel.
- `chat_configuration_arn`: The ARN of the MicrosoftTeamsChannelConfiguration to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChannelName"`: The name of the Microsoft Teams channel.
- `"GuardrailPolicyArns"`: The list of IAM policy ARNs that are applied as channel
guardrails. The AWS managed 'AdministratorAccess' policy is applied by default if this is
not set.
- `"IamRoleArn"`: The ARN of the IAM role that defines the permissions for AWS Chatbot.
This is a user-defined role that AWS Chatbot will assume. This is not the service-linked
role. For more information, see IAM Policies for AWS Chatbot.
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"SnsTopicArns"`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `"UserAuthorizationRequired"`: Enables use of a user role requirement in your chat
configuration.
"""
function update_microsoft_teams_channel_configuration(
ChannelId, ChatConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/update-ms-teams-channel-configuration",
Dict{String,Any}(
"ChannelId" => ChannelId, "ChatConfigurationArn" => ChatConfigurationArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_microsoft_teams_channel_configuration(
ChannelId,
ChatConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/update-ms-teams-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChannelId" => ChannelId, "ChatConfigurationArn" => ChatConfigurationArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_slack_channel_configuration(chat_configuration_arn, slack_channel_id)
update_slack_channel_configuration(chat_configuration_arn, slack_channel_id, params::Dict{String,<:Any})
Updates Slack Channel Configuration
# Arguments
- `chat_configuration_arn`: The ARN of the SlackChannelConfiguration to update.
- `slack_channel_id`: The ID of the Slack channel. To get the ID, open Slack, right click
on the channel name in the left pane, then choose Copy Link. The channel ID is the
9-character string at the end of the URL. For example, ABCBBLZZZ.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"GuardrailPolicyArns"`: The list of IAM policy ARNs that are applied as channel
guardrails. The AWS managed 'AdministratorAccess' policy is applied by default if this is
not set.
- `"IamRoleArn"`: The ARN of the IAM role that defines the permissions for AWS Chatbot.
This is a user-defined role that AWS Chatbot will assume. This is not the service-linked
role. For more information, see IAM Policies for AWS Chatbot.
- `"LoggingLevel"`: Logging levels include ERROR, INFO, or NONE.
- `"SlackChannelName"`: The name of the Slack Channel.
- `"SnsTopicArns"`: The ARNs of the SNS topics that deliver notifications to AWS Chatbot.
- `"UserAuthorizationRequired"`: Enables use of a user role requirement in your chat
configuration.
"""
function update_slack_channel_configuration(
ChatConfigurationArn, SlackChannelId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chatbot(
"POST",
"/update-slack-channel-configuration",
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn,
"SlackChannelId" => SlackChannelId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_slack_channel_configuration(
ChatConfigurationArn,
SlackChannelId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chatbot(
"POST",
"/update-slack-channel-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChatConfigurationArn" => ChatConfigurationArn,
"SlackChannelId" => SlackChannelId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 286299 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime
using AWS.Compat
using AWS.UUIDs
"""
associate_phone_number_with_user(e164_phone_number, account_id, user_id)
associate_phone_number_with_user(e164_phone_number, account_id, user_id, params::Dict{String,<:Any})
Associates a phone number with the specified Amazon Chime user.
# Arguments
- `e164_phone_number`: The phone number, in E.164 format.
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function associate_phone_number_with_user(
E164PhoneNumber, accountId, userId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=associate-phone-number",
Dict{String,Any}("E164PhoneNumber" => E164PhoneNumber);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_phone_number_with_user(
E164PhoneNumber,
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=associate-phone-number",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumber" => E164PhoneNumber), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_phone_numbers_with_voice_connector(e164_phone_numbers, voice_connector_id)
associate_phone_numbers_with_voice_connector(e164_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Associates phone numbers with the specified Amazon Chime Voice Connector. This API is is
no longer supported and will not be updated. We recommend using the latest version,
AssociatePhoneNumbersWithVoiceConnector, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceAssociate"`: If true, associates the provided phone numbers with the provided
Amazon Chime Voice Connector and removes any previously existing associations. If false,
does not associate any phone numbers that have previously existing associations.
"""
function associate_phone_numbers_with_voice_connector(
E164PhoneNumbers, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=associate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_phone_numbers_with_voice_connector(
E164PhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=associate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_phone_numbers_with_voice_connector_group(e164_phone_numbers, voice_connector_group_id)
associate_phone_numbers_with_voice_connector_group(e164_phone_numbers, voice_connector_group_id, params::Dict{String,<:Any})
Associates phone numbers with the specified Amazon Chime Voice Connector group. This API
is is no longer supported and will not be updated. We recommend using the latest version,
AssociatePhoneNumbersWithVoiceConnectorGroup, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_group_id`: The Amazon Chime Voice Connector group ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceAssociate"`: If true, associates the provided phone numbers with the provided
Amazon Chime Voice Connector Group and removes any previously existing associations. If
false, does not associate any phone numbers that have previously existing associations.
"""
function associate_phone_numbers_with_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=associate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_phone_numbers_with_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=associate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_signin_delegate_groups_with_account(signin_delegate_groups, account_id)
associate_signin_delegate_groups_with_account(signin_delegate_groups, account_id, params::Dict{String,<:Any})
Associates the specified sign-in delegate groups with the specified Amazon Chime account.
# Arguments
- `signin_delegate_groups`: The sign-in delegate groups.
- `account_id`: The Amazon Chime account ID.
"""
function associate_signin_delegate_groups_with_account(
SigninDelegateGroups, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)?operation=associate-signin-delegate-groups",
Dict{String,Any}("SigninDelegateGroups" => SigninDelegateGroups);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_signin_delegate_groups_with_account(
SigninDelegateGroups,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)?operation=associate-signin-delegate-groups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("SigninDelegateGroups" => SigninDelegateGroups),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_create_attendee(attendees, meeting_id)
batch_create_attendee(attendees, meeting_id, params::Dict{String,<:Any})
Creates up to 100 new attendees for an active Amazon Chime SDK meeting. This API is is no
longer supported and will not be updated. We recommend using the latest version,
BatchCreateAttendee, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide. For more information about the Amazon
Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime SDK Developer Guide.
# Arguments
- `attendees`: The request containing the attendees to create.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function batch_create_attendee(
Attendees, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees?operation=batch-create",
Dict{String,Any}("Attendees" => Attendees);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_attendee(
Attendees,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees?operation=batch-create",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Attendees" => Attendees), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_create_channel_membership(member_arns, channel_arn)
batch_create_channel_membership(member_arns, channel_arn, params::Dict{String,<:Any})
Adds a specified number of users to a channel. This API is is no longer supported and
will not be updated. We recommend using the latest version, BatchCreateChannelMembership,
in the Amazon Chime SDK. Using the latest version requires migrating to a dedicated
namespace. For more information, refer to Migrating from the Amazon Chime namespace in the
Amazon Chime SDK Developer Guide.
# Arguments
- `member_arns`: The ARNs of the members you want to add to the channel.
- `channel_arn`: The ARN of the channel to which you're adding users.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Type"`: The membership type of a user, DEFAULT or HIDDEN. Default members are always
returned as part of ListChannelMemberships. Hidden members are only returned if the type
filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned.
This is only supported by moderators.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function batch_create_channel_membership(
MemberArns, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/channels/$(channelArn)/memberships?operation=batch-create",
Dict{String,Any}("MemberArns" => MemberArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_channel_membership(
MemberArns,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/memberships?operation=batch-create",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("MemberArns" => MemberArns), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_create_room_membership(membership_item_list, account_id, room_id)
batch_create_room_membership(membership_item_list, account_id, room_id, params::Dict{String,<:Any})
Adds up to 50 members to a chat room in an Amazon Chime Enterprise account. Members can be
users or bots. The member role designates whether the member is a chat room administrator
or a general chat room member.
# Arguments
- `membership_item_list`: The list of membership items.
- `account_id`: The Amazon Chime account ID.
- `room_id`: The room ID.
"""
function batch_create_room_membership(
MembershipItemList, accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships?operation=batch-create",
Dict{String,Any}("MembershipItemList" => MembershipItemList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_room_membership(
MembershipItemList,
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships?operation=batch-create",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("MembershipItemList" => MembershipItemList), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_phone_number(phone_number_ids)
batch_delete_phone_number(phone_number_ids, params::Dict{String,<:Any})
Moves phone numbers into the Deletion queue. Phone numbers must be disassociated from any
users or Amazon Chime Voice Connectors before they can be deleted. Phone numbers remain
in the Deletion queue for 7 days before they are deleted permanently.
# Arguments
- `phone_number_ids`: List of phone number IDs.
"""
function batch_delete_phone_number(
PhoneNumberIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/phone-numbers?operation=batch-delete",
Dict{String,Any}("PhoneNumberIds" => PhoneNumberIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_phone_number(
PhoneNumberIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/phone-numbers?operation=batch-delete",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PhoneNumberIds" => PhoneNumberIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_suspend_user(user_id_list, account_id)
batch_suspend_user(user_id_list, account_id, params::Dict{String,<:Any})
Suspends up to 50 users from a Team or EnterpriseLWA Amazon Chime account. For more
information about different account types, see Managing Your Amazon Chime Accounts in the
Amazon Chime Administration Guide. Users suspended from a Team account are disassociated
from the account,but they can continue to use Amazon Chime as free users. To remove the
suspension from suspended Team account users, invite them to the Team account again. You
can use the InviteUsers action to do so. Users suspended from an EnterpriseLWA account are
immediately signed out of Amazon Chime and can no longer sign in. To remove the suspension
from suspended EnterpriseLWA account users, use the BatchUnsuspendUser action. To sign out
users without suspending them, use the LogoutUser action.
# Arguments
- `user_id_list`: The request containing the user IDs to suspend.
- `account_id`: The Amazon Chime account ID.
"""
function batch_suspend_user(
UserIdList, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=suspend",
Dict{String,Any}("UserIdList" => UserIdList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_suspend_user(
UserIdList,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=suspend",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("UserIdList" => UserIdList), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_unsuspend_user(user_id_list, account_id)
batch_unsuspend_user(user_id_list, account_id, params::Dict{String,<:Any})
Removes the suspension from up to 50 previously suspended users for the specified Amazon
Chime EnterpriseLWA account. Only users on EnterpriseLWA accounts can be unsuspended using
this action. For more information about different account types, see Managing Your Amazon
Chime Accounts in the account types, in the Amazon Chime Administration Guide. Previously
suspended users who are unsuspended using this action are returned to Registered status.
Users who are not previously suspended are ignored.
# Arguments
- `user_id_list`: The request containing the user IDs to unsuspend.
- `account_id`: The Amazon Chime account ID.
"""
function batch_unsuspend_user(
UserIdList, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=unsuspend",
Dict{String,Any}("UserIdList" => UserIdList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_unsuspend_user(
UserIdList,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=unsuspend",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("UserIdList" => UserIdList), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_update_phone_number(update_phone_number_request_items)
batch_update_phone_number(update_phone_number_request_items, params::Dict{String,<:Any})
Updates phone number product types or calling names. You can update one attribute at a time
for each UpdatePhoneNumberRequestItem. For example, you can update the product type or the
calling name. For toll-free numbers, you cannot use the Amazon Chime Business Calling
product type. For numbers outside the U.S., you must use the Amazon Chime SIP Media
Application Dial-In product type. Updates to outbound calling names can take up to 72 hours
to complete. Pending updates to outbound calling names must be complete before you can
request another update.
# Arguments
- `update_phone_number_request_items`: The request containing the phone number IDs and
product types or calling names to update.
"""
function batch_update_phone_number(
UpdatePhoneNumberRequestItems; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/phone-numbers?operation=batch-update",
Dict{String,Any}("UpdatePhoneNumberRequestItems" => UpdatePhoneNumberRequestItems);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_update_phone_number(
UpdatePhoneNumberRequestItems,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/phone-numbers?operation=batch-update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"UpdatePhoneNumberRequestItems" => UpdatePhoneNumberRequestItems
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_update_user(update_user_request_items, account_id)
batch_update_user(update_user_request_items, account_id, params::Dict{String,<:Any})
Updates user details within the UpdateUserRequestItem object for up to 20 users for the
specified Amazon Chime account. Currently, only LicenseType updates are supported for this
action.
# Arguments
- `update_user_request_items`: The request containing the user IDs and details to update.
- `account_id`: The Amazon Chime account ID.
"""
function batch_update_user(
UpdateUserRequestItems, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users",
Dict{String,Any}("UpdateUserRequestItems" => UpdateUserRequestItems);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_update_user(
UpdateUserRequestItems,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("UpdateUserRequestItems" => UpdateUserRequestItems),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_account(name)
create_account(name, params::Dict{String,<:Any})
Creates an Amazon Chime account under the administrator's AWS account. Only Team account
types are currently supported for this action. For more information about different account
types, see Managing Your Amazon Chime Accounts in the Amazon Chime Administration Guide.
# Arguments
- `name`: The name of the Amazon Chime account.
"""
function create_account(Name; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_account(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance(client_request_token, name)
create_app_instance(client_request_token, name, params::Dict{String,<:Any})
Creates an Amazon Chime SDK messaging AppInstance under an AWS account. Only SDK messaging
customers use this API. CreateAppInstance supports idempotency behavior as described in the
AWS API Standard. This API is is no longer supported and will not be updated. We
recommend using the latest version, CreateAppInstance, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `client_request_token`: The ClientRequestToken of the AppInstance.
- `name`: The name of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata of the AppInstance. Limited to a 1KB string in UTF-8.
- `"Tags"`: Tags assigned to the AppInstance.
"""
function create_app_instance(
ClientRequestToken, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/app-instances",
Dict{String,Any}("ClientRequestToken" => ClientRequestToken, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance(
ClientRequestToken,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/app-instances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken, "Name" => Name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance_admin(app_instance_admin_arn, app_instance_arn)
create_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Promotes an AppInstanceUser to an AppInstanceAdmin. The promoted user can perform the
following actions. This API is is no longer supported and will not be updated. We
recommend using the latest version, CreateAppInstanceAdmin, in the Amazon Chime SDK. Using
the latest version requires migrating to a dedicated namespace. For more information, refer
to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
ChannelModerator actions across all channels in the AppInstance. DeleteChannelMessage
actions. Only an AppInstanceUser can be promoted to an AppInstanceAdmin role.
# Arguments
- `app_instance_admin_arn`: The ARN of the administrator of the current AppInstance.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function create_app_instance_admin(
AppInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/app-instances/$(appInstanceArn)/admins",
Dict{String,Any}("AppInstanceAdminArn" => AppInstanceAdminArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance_admin(
AppInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/app-instances/$(appInstanceArn)/admins",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AppInstanceAdminArn" => AppInstanceAdminArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance_user(app_instance_arn, app_instance_user_id, client_request_token, name)
create_app_instance_user(app_instance_arn, app_instance_user_id, client_request_token, name, params::Dict{String,<:Any})
Creates a user under an Amazon Chime AppInstance. The request consists of a unique
appInstanceUserId and Name for that user. This API is is no longer supported and will not
be updated. We recommend using the latest version, CreateAppInstanceUser, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance request.
- `app_instance_user_id`: The user ID of the AppInstance.
- `client_request_token`: The token assigned to the user requesting an AppInstance.
- `name`: The user's name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The request's metadata. Limited to a 1KB string in UTF-8.
- `"Tags"`: Tags assigned to the AppInstanceUser.
"""
function create_app_instance_user(
AppInstanceArn,
AppInstanceUserId,
ClientRequestToken,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/app-instance-users",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"AppInstanceUserId" => AppInstanceUserId,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance_user(
AppInstanceArn,
AppInstanceUserId,
ClientRequestToken,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/app-instance-users",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"AppInstanceUserId" => AppInstanceUserId,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_attendee(external_user_id, meeting_id)
create_attendee(external_user_id, meeting_id, params::Dict{String,<:Any})
Creates a new attendee for an active Amazon Chime SDK meeting. For more information about
the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime SDK Developer
Guide. This API is is no longer supported and will not be updated. We recommend using
the latest version, CreateAttendee, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `external_user_id`: The Amazon Chime SDK external user ID. An idempotency token. Links
the attendee to an identity managed by a builder application.
- `meeting_id`: The Amazon Chime SDK meeting ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tag key-value pairs.
"""
function create_attendee(
ExternalUserId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees",
Dict{String,Any}("ExternalUserId" => ExternalUserId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_attendee(
ExternalUserId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExternalUserId" => ExternalUserId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_bot(display_name, account_id)
create_bot(display_name, account_id, params::Dict{String,<:Any})
Creates a bot for an Amazon Chime Enterprise account.
# Arguments
- `display_name`: The bot display name.
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Domain"`: The domain of the Amazon Chime Enterprise account.
"""
function create_bot(
DisplayName, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/bots",
Dict{String,Any}("DisplayName" => DisplayName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_bot(
DisplayName,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/bots",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DisplayName" => DisplayName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel(app_instance_arn, client_request_token, name)
create_channel(app_instance_arn, client_request_token, name, params::Dict{String,<:Any})
Creates a channel to which you can add users and send messages. Restriction: You can't
change a channel's privacy. The x-amz-chime-bearer request header is mandatory. Use the
AppInstanceUserArn of the user that makes the API call as the value in the header. This
API is is no longer supported and will not be updated. We recommend using the latest
version, CreateChannel, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the channel request.
- `client_request_token`: The client token for the request. An Idempotency token.
- `name`: The name of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata of the creation request. Limited to 1KB and UTF-8.
- `"Mode"`: The channel mode: UNRESTRICTED or RESTRICTED. Administrators, moderators, and
channel members can add themselves and other members to unrestricted channels. Only
administrators and moderators can add members to restricted channels.
- `"Privacy"`: The channel's privacy level: PUBLIC or PRIVATE. Private channels aren't
discoverable by users outside the channel. Public channels are discoverable by anyone in
the AppInstance.
- `"Tags"`: The tags for the creation request.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function create_channel(
AppInstanceArn,
ClientRequestToken,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel(
AppInstanceArn,
ClientRequestToken,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_ban(member_arn, channel_arn)
create_channel_ban(member_arn, channel_arn, params::Dict{String,<:Any})
Permanently bans a member from a channel. Moderators can't add banned members to a channel.
To undo a ban, you first have to DeleteChannelBan, and then CreateChannelMembership. Bans
are cleaned up when you delete users or channels. If you ban a user who is already part of
a channel, that user is automatically kicked from the channel. The x-amz-chime-bearer
request header is mandatory. Use the AppInstanceUserArn of the user that makes the API call
as the value in the header. This API is is no longer supported and will not be updated.
We recommend using the latest version, CreateChannelBan, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `member_arn`: The ARN of the member being banned.
- `channel_arn`: The ARN of the ban request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function create_channel_ban(
MemberArn, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/channels/$(channelArn)/bans",
Dict{String,Any}("MemberArn" => MemberArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_ban(
MemberArn,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/bans",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("MemberArn" => MemberArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_membership(member_arn, type, channel_arn)
create_channel_membership(member_arn, type, channel_arn, params::Dict{String,<:Any})
Adds a user to a channel. The InvitedBy response field is derived from the request header.
A channel member can: List messages Send messages Receive messages Edit their own
messages Leave the channel Privacy settings impact this action as follows: Public
Channels: You do not need to be a member to list messages, but you must be a member to send
messages. Private Channels: You must be a member to list or send messages. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version, CreateChannelMembership, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Arguments
- `member_arn`: The ARN of the member you want to add to the channel.
- `type`: The membership type of a user, DEFAULT or HIDDEN. Default members are always
returned as part of ListChannelMemberships. Hidden members are only returned if the type
filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned.
This is only supported by moderators.
- `channel_arn`: The ARN of the channel to which you're adding users.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function create_channel_membership(
MemberArn, Type, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/channels/$(channelArn)/memberships",
Dict{String,Any}("MemberArn" => MemberArn, "Type" => Type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_membership(
MemberArn,
Type,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/memberships",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("MemberArn" => MemberArn, "Type" => Type), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_moderator(channel_moderator_arn, channel_arn)
create_channel_moderator(channel_moderator_arn, channel_arn, params::Dict{String,<:Any})
Creates a new ChannelModerator. A channel moderator can: Add and remove other members of
the channel. Add and remove other moderators of the channel. Add and remove user bans
for the channel. Redact messages in the channel. List messages in the channel. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version, CreateChannelModerator, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Arguments
- `channel_moderator_arn`: The ARN of the moderator.
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function create_channel_moderator(
ChannelModeratorArn, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/channels/$(channelArn)/moderators",
Dict{String,Any}("ChannelModeratorArn" => ChannelModeratorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_moderator(
ChannelModeratorArn,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/moderators",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ChannelModeratorArn" => ChannelModeratorArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_capture_pipeline(sink_arn, sink_type, source_arn, source_type)
create_media_capture_pipeline(sink_arn, sink_type, source_arn, source_type, params::Dict{String,<:Any})
Creates a media capture pipeline. This API is is no longer supported and will not be
updated. We recommend using the latest version, CreateMediaCapturePipeline, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `sink_arn`: The ARN of the sink type.
- `sink_type`: Destination type to which the media artifacts are saved. You must use an S3
bucket.
- `source_arn`: ARN of the source from which the media artifacts are captured.
- `source_type`: Source type from which the media artifacts will be captured. A Chime SDK
Meeting is the only supported source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChimeSdkMeetingConfiguration"`: The configuration for a specified media capture
pipeline. SourceType must be ChimeSdkMeeting.
- `"ClientRequestToken"`: The unique identifier for the client request. The token makes the
API request idempotent. Use a different token for different media pipeline requests.
"""
function create_media_capture_pipeline(
SinkArn,
SinkType,
SourceArn,
SourceType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/media-capture-pipelines",
Dict{String,Any}(
"SinkArn" => SinkArn,
"SinkType" => SinkType,
"SourceArn" => SourceArn,
"SourceType" => SourceType,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_capture_pipeline(
SinkArn,
SinkType,
SourceArn,
SourceType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/media-capture-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"SinkArn" => SinkArn,
"SinkType" => SinkType,
"SourceArn" => SourceArn,
"SourceType" => SourceType,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_meeting(client_request_token)
create_meeting(client_request_token, params::Dict{String,<:Any})
Creates a new Amazon Chime SDK meeting in the specified media Region with no initial
attendees. For more information about specifying media Regions, see Amazon Chime SDK Media
Regions in the Amazon Chime SDK Developer Guide . For more information about the Amazon
Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime SDK Developer Guide. This
API is is no longer supported and will not be updated. We recommend using the latest
version, CreateMeeting, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `client_request_token`: The unique identifier for the client request. Use a different
token for different meetings.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExternalMeetingId"`: The external meeting ID.
- `"MediaRegion"`: The Region in which to create the meeting. Default: us-east-1.
Available values: af-south-1 , ap-northeast-1 , ap-northeast-2 , ap-south-1 ,
ap-southeast-1 , ap-southeast-2 , ca-central-1 , eu-central-1 , eu-north-1 , eu-south-1 ,
eu-west-1 , eu-west-2 , eu-west-3 , sa-east-1 , us-east-1 , us-east-2 , us-west-1 ,
us-west-2 .
- `"MeetingHostId"`: Reserved.
- `"NotificationsConfiguration"`: The configuration for resource targets to receive
notifications when meeting and attendee events occur.
- `"Tags"`: The tag key-value pairs.
"""
function create_meeting(
ClientRequestToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings",
Dict{String,Any}("ClientRequestToken" => ClientRequestToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_meeting(
ClientRequestToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ClientRequestToken" => ClientRequestToken), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_meeting_dial_out(from_phone_number, join_token, to_phone_number, meeting_id)
create_meeting_dial_out(from_phone_number, join_token, to_phone_number, meeting_id, params::Dict{String,<:Any})
Uses the join token and call metadata in a meeting request (From number, To number, and so
forth) to initiate an outbound call to a public switched telephone network (PSTN) and join
them into a Chime meeting. Also ensures that the From number belongs to the customer. To
play welcome audio or implement an interactive voice response (IVR), use the
CreateSipMediaApplicationCall action with the corresponding SIP media application ID.
This API is is not available in a dedicated namespace.
# Arguments
- `from_phone_number`: Phone number used as the caller ID when the remote party receives a
call.
- `join_token`: Token used by the Amazon Chime SDK attendee. Call the CreateAttendee action
to get a join token.
- `to_phone_number`: Phone number called when inviting someone to a meeting.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function create_meeting_dial_out(
FromPhoneNumber,
JoinToken,
ToPhoneNumber,
meetingId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/dial-outs",
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber,
"JoinToken" => JoinToken,
"ToPhoneNumber" => ToPhoneNumber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_meeting_dial_out(
FromPhoneNumber,
JoinToken,
ToPhoneNumber,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/dial-outs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber,
"JoinToken" => JoinToken,
"ToPhoneNumber" => ToPhoneNumber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_meeting_with_attendees(client_request_token)
create_meeting_with_attendees(client_request_token, params::Dict{String,<:Any})
Creates a new Amazon Chime SDK meeting in the specified media Region, with attendees. For
more information about specifying media Regions, see Amazon Chime SDK Media Regions in the
Amazon Chime SDK Developer Guide . For more information about the Amazon Chime SDK, see
Using the Amazon Chime SDK in the Amazon Chime SDK Developer Guide . This API is is no
longer supported and will not be updated. We recommend using the latest version,
CreateMeetingWithAttendees, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `client_request_token`: The unique identifier for the client request. Use a different
token for different meetings.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Attendees"`: The request containing the attendees to create.
- `"ExternalMeetingId"`: The external meeting ID.
- `"MediaRegion"`: The Region in which to create the meeting. Default: us-east-1 .
Available values: af-south-1 , ap-northeast-1 , ap-northeast-2 , ap-south-1 ,
ap-southeast-1 , ap-southeast-2 , ca-central-1 , eu-central-1 , eu-north-1 , eu-south-1 ,
eu-west-1 , eu-west-2 , eu-west-3 , sa-east-1 , us-east-1 , us-east-2 , us-west-1 ,
us-west-2 .
- `"MeetingHostId"`: Reserved.
- `"NotificationsConfiguration"`: The resource target configurations for receiving Amazon
Chime SDK meeting and attendee event notifications. The Amazon Chime SDK supports resource
targets located in the US East (N. Virginia) AWS Region (us-east-1).
- `"Tags"`: The tag key-value pairs.
"""
function create_meeting_with_attendees(
ClientRequestToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings?operation=create-attendees",
Dict{String,Any}("ClientRequestToken" => ClientRequestToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_meeting_with_attendees(
ClientRequestToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings?operation=create-attendees",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("ClientRequestToken" => ClientRequestToken), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_phone_number_order(e164_phone_numbers, product_type)
create_phone_number_order(e164_phone_numbers, product_type, params::Dict{String,<:Any})
Creates an order for phone numbers to be provisioned. For toll-free numbers, you cannot use
the Amazon Chime Business Calling product type. For numbers outside the U.S., you must use
the Amazon Chime SIP Media Application Dial-In product type.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `product_type`: The phone number product type.
"""
function create_phone_number_order(
E164PhoneNumbers, ProductType; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/phone-number-orders",
Dict{String,Any}(
"E164PhoneNumbers" => E164PhoneNumbers, "ProductType" => ProductType
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_phone_number_order(
E164PhoneNumbers,
ProductType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/phone-number-orders",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"E164PhoneNumbers" => E164PhoneNumbers, "ProductType" => ProductType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_proxy_session(capabilities, participant_phone_numbers, voice_connector_id)
create_proxy_session(capabilities, participant_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Creates a proxy session on the specified Amazon Chime Voice Connector for the specified
participant phone numbers. This API is is no longer supported and will not be updated. We
recommend using the latest version, CreateProxySession, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `capabilities`: The proxy session capabilities.
- `participant_phone_numbers`: The participant phone numbers.
- `voice_connector_id`: The Amazon Chime voice connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpiryMinutes"`: The number of minutes allowed for the proxy session.
- `"GeoMatchLevel"`: The preference for matching the country or area code of the proxy
phone number with that of the first participant.
- `"GeoMatchParams"`: The country and area code for the proxy phone number.
- `"Name"`: The name of the proxy session.
- `"NumberSelectionBehavior"`: The preference for proxy phone number reuse, or stickiness,
between the same participants across sessions.
"""
function create_proxy_session(
Capabilities,
ParticipantPhoneNumbers,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
Dict{String,Any}(
"Capabilities" => Capabilities,
"ParticipantPhoneNumbers" => ParticipantPhoneNumbers,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_proxy_session(
Capabilities,
ParticipantPhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Capabilities" => Capabilities,
"ParticipantPhoneNumbers" => ParticipantPhoneNumbers,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_room(name, account_id)
create_room(name, account_id, params::Dict{String,<:Any})
Creates a chat room for the specified Amazon Chime Enterprise account.
# Arguments
- `name`: The room name.
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The idempotency token for the request.
"""
function create_room(Name, accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/rooms",
Dict{String,Any}("Name" => Name, "ClientRequestToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_room(
Name,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "ClientRequestToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_room_membership(member_id, account_id, room_id)
create_room_membership(member_id, account_id, room_id, params::Dict{String,<:Any})
Adds a member to a chat room in an Amazon Chime Enterprise account. A member can be either
a user or a bot. The member role designates whether the member is a chat room administrator
or a general chat room member.
# Arguments
- `member_id`: The Amazon Chime member ID (user ID or bot ID).
- `account_id`: The Amazon Chime account ID.
- `room_id`: The room ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Role"`: The role of the member.
"""
function create_room_membership(
MemberId, accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships",
Dict{String,Any}("MemberId" => MemberId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_room_membership(
MemberId,
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("MemberId" => MemberId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_media_application(aws_region, endpoints, name)
create_sip_media_application(aws_region, endpoints, name, params::Dict{String,<:Any})
Creates a SIP media application. This API is is no longer supported and will not be
updated. We recommend using the latest version, CreateSipMediaApplication, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `aws_region`: The AWS Region assigned to the SIP media application.
- `endpoints`: List of endpoints (Lambda Amazon Resource Names) specified for the SIP media
application. Currently, only one endpoint is supported.
- `name`: The SIP media application name.
"""
function create_sip_media_application(
AwsRegion, Endpoints, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/sip-media-applications",
Dict{String,Any}(
"AwsRegion" => AwsRegion, "Endpoints" => Endpoints, "Name" => Name
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_media_application(
AwsRegion,
Endpoints,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-media-applications",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AwsRegion" => AwsRegion, "Endpoints" => Endpoints, "Name" => Name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_media_application_call(from_phone_number, to_phone_number, sip_media_application_id)
create_sip_media_application_call(from_phone_number, to_phone_number, sip_media_application_id, params::Dict{String,<:Any})
Creates an outbound call to a phone number from the phone number specified in the request,
and it invokes the endpoint of the specified sipMediaApplicationId. This API is is no
longer supported and will not be updated. We recommend using the latest version,
CreateSipMediaApplicationCall, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `from_phone_number`: The phone number that a user calls from. This is a phone number in
your Amazon Chime phone number inventory.
- `to_phone_number`: The phone number that the service should call.
- `sip_media_application_id`: The ID of the SIP media application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SipHeaders"`: The SIP headers added to an outbound call leg.
"""
function create_sip_media_application_call(
FromPhoneNumber,
ToPhoneNumber,
sipMediaApplicationId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls",
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber, "ToPhoneNumber" => ToPhoneNumber
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_media_application_call(
FromPhoneNumber,
ToPhoneNumber,
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber, "ToPhoneNumber" => ToPhoneNumber
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_rule(name, target_applications, trigger_type, trigger_value)
create_sip_rule(name, target_applications, trigger_type, trigger_value, params::Dict{String,<:Any})
Creates a SIP rule which can be used to run a SIP media application as a target for a
specific trigger type. This API is is no longer supported and will not be updated. We
recommend using the latest version, CreateSipRule, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name of the SIP rule.
- `target_applications`: List of SIP media applications with priority and AWS Region. Only
one SIP application per AWS Region can be used.
- `trigger_type`: The type of trigger assigned to the SIP rule in TriggerValue, currently
RequestUriHostname or ToPhoneNumber.
- `trigger_value`: If TriggerType is RequestUriHostname, the value can be the outbound host
name of an Amazon Chime Voice Connector. If TriggerType is ToPhoneNumber, the value can be
a customer-owned phone number in the E164 format. The SipMediaApplication specified in the
SipRule is triggered if the request URI in an incoming SIP request matches the
RequestUriHostname, or if the To header in the incoming SIP request matches the
ToPhoneNumber value.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: Enables or disables a rule. You must disable rules before you can delete
them.
"""
function create_sip_rule(
Name,
TargetApplications,
TriggerType,
TriggerValue;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-rules",
Dict{String,Any}(
"Name" => Name,
"TargetApplications" => TargetApplications,
"TriggerType" => TriggerType,
"TriggerValue" => TriggerValue,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_rule(
Name,
TargetApplications,
TriggerType,
TriggerValue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-rules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"TargetApplications" => TargetApplications,
"TriggerType" => TriggerType,
"TriggerValue" => TriggerValue,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_user(account_id)
create_user(account_id, params::Dict{String,<:Any})
Creates a user under the specified Amazon Chime account.
# Arguments
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Email"`: The user's email address.
- `"UserType"`: The user type.
- `"Username"`: The user name.
"""
function create_user(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/users?operation=create";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_user(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=create",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_connector(name, require_encryption)
create_voice_connector(name, require_encryption, params::Dict{String,<:Any})
Creates an Amazon Chime Voice Connector under the administrator's AWS account. You can
choose to create an Amazon Chime Voice Connector in a specific AWS Region. Enabling
CreateVoiceConnectorRequestRequireEncryption configures your Amazon Chime Voice Connector
to use TLS transport for SIP signaling and Secure RTP (SRTP) for media. Inbound calls use
TLS transport, and unencrypted outbound calls are blocked. This API is is no longer
supported and will not be updated. We recommend using the latest version,
CreateVoiceConnector, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name of the Amazon Chime Voice Connector.
- `require_encryption`: When enabled, requires encryption for the Amazon Chime Voice
Connector.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AwsRegion"`: The AWS Region in which the Amazon Chime Voice Connector is created.
Default value: us-east-1 .
"""
function create_voice_connector(
Name, RequireEncryption; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connectors",
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_connector(
Name,
RequireEncryption,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_connector_group(name)
create_voice_connector_group(name, params::Dict{String,<:Any})
Creates an Amazon Chime Voice Connector group under the administrator's AWS account. You
can associate Amazon Chime Voice Connectors with the Amazon Chime Voice Connector group by
including VoiceConnectorItems in the request. You can include Amazon Chime Voice Connectors
from different AWS Regions in your group. This creates a fault tolerant mechanism for
fallback in case of availability events. This API is is no longer supported and will not
be updated. We recommend using the latest version, CreateVoiceConnectorGroup, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `name`: The name of the Amazon Chime Voice Connector group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VoiceConnectorItems"`: The Amazon Chime Voice Connectors to route inbound calls to.
"""
function create_voice_connector_group(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connector-groups",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_connector_group(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connector-groups",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_account(account_id)
delete_account(account_id, params::Dict{String,<:Any})
Deletes the specified Amazon Chime account. You must suspend all users before deleting Team
account. You can use the BatchSuspendUser action to dodo. For EnterpriseLWA and
EnterpriseAD accounts, you must release the claimed domains for your Amazon Chime account
before deletion. As soon as you release the domain, all users under that account are
suspended. Deleted accounts appear in your Disabled accounts list for 90 days. To restore
deleted account from your Disabled accounts list, you must contact AWS Support. After 90
days, deleted accounts are permanently removed from your Disabled accounts list.
# Arguments
- `account_id`: The Amazon Chime account ID.
"""
function delete_account(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"DELETE",
"/accounts/$(accountId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_account(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/accounts/$(accountId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance(app_instance_arn)
delete_app_instance(app_instance_arn, params::Dict{String,<:Any})
Deletes an AppInstance and all associated data asynchronously. This API is is no longer
supported and will not be updated. We recommend using the latest version,
DeleteAppInstance, in the Amazon Chime SDK. Using the latest version requires migrating to
a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function delete_app_instance(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_admin(app_instance_admin_arn, app_instance_arn)
delete_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Demotes an AppInstanceAdmin to an AppInstanceUser. This action does not delete the user.
This API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteAppInstanceAdmin, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_admin_arn`: The ARN of the AppInstance's administrator.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function delete_app_instance_admin(
appInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_admin(
appInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_streaming_configurations(app_instance_arn)
delete_app_instance_streaming_configurations(app_instance_arn, params::Dict{String,<:Any})
Deletes the streaming configurations of an AppInstance. This API is is no longer
supported and will not be updated. We recommend using the latest version,
DeleteAppInstanceStreamingConfigurations, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the streaming configurations being deleted.
"""
function delete_app_instance_streaming_configurations(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)/streaming-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_streaming_configurations(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/app-instances/$(appInstanceArn)/streaming-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_user(app_instance_user_arn)
delete_app_instance_user(app_instance_user_arn, params::Dict{String,<:Any})
Deletes an AppInstanceUser. This API is is no longer supported and will not be updated.
We recommend using the latest version, DeleteAppInstanceUser, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_user_arn`: The ARN of the user request being deleted.
"""
function delete_app_instance_user(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_user(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_attendee(attendee_id, meeting_id)
delete_attendee(attendee_id, meeting_id, params::Dict{String,<:Any})
Deletes an attendee from the specified Amazon Chime SDK meeting and deletes their
JoinToken. Attendees are automatically deleted when a Amazon Chime SDK meeting is deleted.
For more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the
Amazon Chime SDK Developer Guide. This API is is no longer supported and will not be
updated. We recommend using the latest version, DeleteAttendee, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function delete_attendee(
attendeeId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/meetings/$(meetingId)/attendees/$(attendeeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_attendee(
attendeeId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/meetings/$(meetingId)/attendees/$(attendeeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel(channel_arn)
delete_channel(channel_arn, params::Dict{String,<:Any})
Immediately makes a channel and its memberships inaccessible and marks them for deletion.
This is an irreversible process. The x-amz-chime-bearer request header is mandatory. Use
the AppInstanceUserArn of the user that makes the API call as the value in the header.
This API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteChannel, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel being deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function delete_channel(channelArn; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"DELETE",
"/channels/$(channelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/channels/$(channelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_ban(channel_arn, member_arn)
delete_channel_ban(channel_arn, member_arn, params::Dict{String,<:Any})
Removes a user from a channel's ban list. The x-amz-chime-bearer request header is
mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in
the header. This API is is no longer supported and will not be updated. We recommend
using the latest version, DeleteChannelBan, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel from which the AppInstanceUser was banned.
- `member_arn`: The ARN of the AppInstanceUser that you want to reinstate.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function delete_channel_ban(
channelArn, memberArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/channels/$(channelArn)/bans/$(memberArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_ban(
channelArn,
memberArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/channels/$(channelArn)/bans/$(memberArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_membership(channel_arn, member_arn)
delete_channel_membership(channel_arn, member_arn, params::Dict{String,<:Any})
Removes a member from a channel. The x-amz-chime-bearer request header is mandatory. Use
the AppInstanceUserArn of the user that makes the API call as the value in the header.
This API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteChannelMembership, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel from which you want to remove the user.
- `member_arn`: The ARN of the member that you're removing from the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function delete_channel_membership(
channelArn, memberArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/channels/$(channelArn)/memberships/$(memberArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_membership(
channelArn,
memberArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/channels/$(channelArn)/memberships/$(memberArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_message(channel_arn, message_id)
delete_channel_message(channel_arn, message_id, params::Dict{String,<:Any})
Deletes a channel message. Only admins can perform this action. Deletion makes messages
inaccessible immediately. A background process deletes any revisions created by
UpdateChannelMessage. The x-amz-chime-bearer request header is mandatory. Use the
AppInstanceUserArn of the user that makes the API call as the value in the header. This
API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteChannelMessage, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID of the message being deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function delete_channel_message(
channelArn, messageId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/channels/$(channelArn)/messages/$(messageId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_message(
channelArn,
messageId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/channels/$(channelArn)/messages/$(messageId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_moderator(channel_arn, channel_moderator_arn)
delete_channel_moderator(channel_arn, channel_moderator_arn, params::Dict{String,<:Any})
Deletes a channel moderator. The x-amz-chime-bearer request header is mandatory. Use the
AppInstanceUserArn of the user that makes the API call as the value in the header. This
API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteChannelModerator, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `channel_moderator_arn`: The ARN of the moderator being deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function delete_channel_moderator(
channelArn, channelModeratorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_moderator(
channelArn,
channelModeratorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_events_configuration(account_id, bot_id)
delete_events_configuration(account_id, bot_id, params::Dict{String,<:Any})
Deletes the events configuration that allows a bot to receive outgoing events.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
"""
function delete_events_configuration(
accountId, botId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/accounts/$(accountId)/bots/$(botId)/events-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_events_configuration(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/accounts/$(accountId)/bots/$(botId)/events-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_media_capture_pipeline(media_pipeline_id)
delete_media_capture_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Deletes the media capture pipeline. This API is is no longer supported and will not be
updated. We recommend using the latest version, DeleteMediaCapturePipeline, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `media_pipeline_id`: The ID of the media capture pipeline being deleted.
"""
function delete_media_capture_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/media-capture-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_media_capture_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/media-capture-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_meeting(meeting_id)
delete_meeting(meeting_id, params::Dict{String,<:Any})
Deletes the specified Amazon Chime SDK meeting. The operation deletes all attendees,
disconnects all clients, and prevents new clients from joining the meeting. For more
information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime
SDK Developer Guide. This API is is no longer supported and will not be updated. We
recommend using the latest version, DeleteMeeting, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function delete_meeting(meetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"DELETE",
"/meetings/$(meetingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_meeting(
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/meetings/$(meetingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_phone_number(phone_number_id)
delete_phone_number(phone_number_id, params::Dict{String,<:Any})
Moves the specified phone number into the Deletion queue. A phone number must be
disassociated from any users or Amazon Chime Voice Connectors before it can be deleted.
Deleted phone numbers remain in the Deletion queue for 7 days before they are deleted
permanently.
# Arguments
- `phone_number_id`: The phone number ID.
"""
function delete_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_proxy_session(proxy_session_id, voice_connector_id)
delete_proxy_session(proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Deletes the specified proxy session from the specified Amazon Chime Voice Connector. This
API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteProxySession, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Amazon Chime voice connector ID.
"""
function delete_proxy_session(
proxySessionId, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_proxy_session(
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_room(account_id, room_id)
delete_room(account_id, room_id, params::Dict{String,<:Any})
Deletes a chat room in an Amazon Chime Enterprise account.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `room_id`: The chat room ID.
"""
function delete_room(accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"DELETE",
"/accounts/$(accountId)/rooms/$(roomId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_room(
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/accounts/$(accountId)/rooms/$(roomId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_room_membership(account_id, member_id, room_id)
delete_room_membership(account_id, member_id, room_id, params::Dict{String,<:Any})
Removes a member from a chat room in an Amazon Chime Enterprise account.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `member_id`: The member ID (user ID or bot ID).
- `room_id`: The room ID.
"""
function delete_room_membership(
accountId, memberId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/accounts/$(accountId)/rooms/$(roomId)/memberships/$(memberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_room_membership(
accountId,
memberId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/accounts/$(accountId)/rooms/$(roomId)/memberships/$(memberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_sip_media_application(sip_media_application_id)
delete_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Deletes a SIP media application. This API is is no longer supported and will not be
updated. We recommend using the latest version, DeleteSipMediaApplication, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function delete_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_sip_rule(sip_rule_id)
delete_sip_rule(sip_rule_id, params::Dict{String,<:Any})
Deletes a SIP rule. You must disable a SIP rule before you can delete it. This API is is
no longer supported and will not be updated. We recommend using the latest version,
DeleteSipRule, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_rule_id`: The SIP rule ID.
"""
function delete_sip_rule(sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"DELETE",
"/sip-rules/$(sipRuleId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_sip_rule(
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/sip-rules/$(sipRuleId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector(voice_connector_id)
delete_voice_connector(voice_connector_id, params::Dict{String,<:Any})
Deletes the specified Amazon Chime Voice Connector. Any phone numbers associated with the
Amazon Chime Voice Connector must be disassociated from it before it can be deleted. This
API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteVoiceConnector, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_emergency_calling_configuration(voice_connector_id)
delete_voice_connector_emergency_calling_configuration(voice_connector_id, params::Dict{String,<:Any})
Deletes the emergency calling configuration details from the specified Amazon Chime Voice
Connector. This API is is no longer supported and will not be updated. We recommend using
the latest version, DeleteVoiceConnectorEmergencyCallingConfiguration, in the Amazon Chime
SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_emergency_calling_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_emergency_calling_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_group(voice_connector_group_id)
delete_voice_connector_group(voice_connector_group_id, params::Dict{String,<:Any})
Deletes the specified Amazon Chime Voice Connector group. Any VoiceConnectorItems and phone
numbers associated with the group must be removed before it can be deleted. This API is
is no longer supported and will not be updated. We recommend using the latest version,
DeleteVoiceConnectorGroup, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_group_id`: The Amazon Chime Voice Connector group ID.
"""
function delete_voice_connector_group(
voiceConnectorGroupId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connector-groups/$(voiceConnectorGroupId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_group(
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connector-groups/$(voiceConnectorGroupId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_origination(voice_connector_id)
delete_voice_connector_origination(voice_connector_id, params::Dict{String,<:Any})
Deletes the origination settings for the specified Amazon Chime Voice Connector. If
emergency calling is configured for the Amazon Chime Voice Connector, it must be deleted
prior to deleting the origination settings. This API is is no longer supported and will
not be updated. We recommend using the latest version, DeleteVoiceConnectorOrigination, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_origination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/origination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_origination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/origination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_proxy(voice_connector_id)
delete_voice_connector_proxy(voice_connector_id, params::Dict{String,<:Any})
Deletes the proxy configuration from the specified Amazon Chime Voice Connector. This API
is is no longer supported and will not be updated. We recommend using the latest version,
DeleteVoiceProxy, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_proxy(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_proxy(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_streaming_configuration(voice_connector_id)
delete_voice_connector_streaming_configuration(voice_connector_id, params::Dict{String,<:Any})
Deletes the streaming configuration for the specified Amazon Chime Voice Connector. This
API is is no longer supported and will not be updated. We recommend using the latest
version, DeleteVoiceConnectorStreamingConfiguration, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_streaming_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_streaming_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_termination(voice_connector_id)
delete_voice_connector_termination(voice_connector_id, params::Dict{String,<:Any})
Deletes the termination settings for the specified Amazon Chime Voice Connector. If
emergency calling is configured for the Amazon Chime Voice Connector, it must be deleted
prior to deleting the termination settings. This API is is no longer supported and will
not be updated. We recommend using the latest version, DeleteVoiceConnectorTermination, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_termination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/termination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_termination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/termination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_termination_credentials(usernames, voice_connector_id)
delete_voice_connector_termination_credentials(usernames, voice_connector_id, params::Dict{String,<:Any})
Deletes the specified SIP credentials used by your equipment to authenticate during call
termination. This API is is no longer supported and will not be updated. We recommend
using the latest version, DeleteVoiceConnectorTerminationCredentials, in the Amazon Chime
SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `usernames`: The RFC2617 compliant username associated with the SIP credentials, in
US-ASCII format.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function delete_voice_connector_termination_credentials(
Usernames, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=delete",
Dict{String,Any}("Usernames" => Usernames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_termination_credentials(
Usernames,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=delete",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Usernames" => Usernames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance(app_instance_arn)
describe_app_instance(app_instance_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstance. This API is is no longer supported and will
not be updated. We recommend using the latest version, DescribeAppInstance, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function describe_app_instance(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_admin(app_instance_admin_arn, app_instance_arn)
describe_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstanceAdmin. This API is is no longer supported and
will not be updated. We recommend using the latest version, DescribeAppInstanceAdmin, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `app_instance_admin_arn`: The ARN of the AppInstanceAdmin.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function describe_app_instance_admin(
appInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_admin(
appInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_user(app_instance_user_arn)
describe_app_instance_user(app_instance_user_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstanceUser. This API is is no longer supported and
will not be updated. We recommend using the latest version, DescribeAppInstanceUser, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
"""
function describe_app_instance_user(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instance-users/$(appInstanceUserArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_user(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instance-users/$(appInstanceUserArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel(channel_arn)
describe_channel(channel_arn, params::Dict{String,<:Any})
Returns the full details of a channel in an Amazon Chime AppInstance. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version, DescribeChannel, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel(channelArn; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/channels/$(channelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_ban(channel_arn, member_arn)
describe_channel_ban(channel_arn, member_arn, params::Dict{String,<:Any})
Returns the full details of a channel ban. The x-amz-chime-bearer request header is
mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in
the header. This API is is no longer supported and will not be updated. We recommend
using the latest version, DescribeChannelBan, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel from which the user is banned.
- `member_arn`: The ARN of the member being banned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel_ban(
channelArn, memberArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/bans/$(memberArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_ban(
channelArn,
memberArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/bans/$(memberArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_membership(channel_arn, member_arn)
describe_channel_membership(channel_arn, member_arn, params::Dict{String,<:Any})
Returns the full details of a user's channel membership. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header. This API is is no longer supported and will not be updated. We
recommend using the latest version, DescribeChannelMembership, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `member_arn`: The ARN of the member.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel_membership(
channelArn, memberArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_membership(
channelArn,
memberArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_membership_for_app_instance_user(app-instance-user-arn, channel_arn)
describe_channel_membership_for_app_instance_user(app-instance-user-arn, channel_arn, params::Dict{String,<:Any})
Returns the details of a channel based on the membership of the specified AppInstanceUser.
The x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user
that makes the API call as the value in the header. This API is is no longer supported
and will not be updated. We recommend using the latest version,
DescribeChannelMembershipForAppInstanceUser, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app-instance-user-arn`: The ARN of the user in a channel.
- `channel_arn`: The ARN of the channel to which the user belongs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel_membership_for_app_instance_user(
app_instance_user_arn, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-membership",
Dict{String,Any}("app-instance-user-arn" => app_instance_user_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_membership_for_app_instance_user(
app_instance_user_arn,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-membership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("app-instance-user-arn" => app_instance_user_arn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_moderated_by_app_instance_user(app-instance-user-arn, channel_arn)
describe_channel_moderated_by_app_instance_user(app-instance-user-arn, channel_arn, params::Dict{String,<:Any})
Returns the full details of a channel moderated by the specified AppInstanceUser. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version,
DescribeChannelModeratedByAppInstanceUser, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app-instance-user-arn`: The ARN of the AppInstanceUser in the moderated channel.
- `channel_arn`: The ARN of the moderated channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel_moderated_by_app_instance_user(
app_instance_user_arn, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-moderated-channel",
Dict{String,Any}("app-instance-user-arn" => app_instance_user_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_moderated_by_app_instance_user(
app_instance_user_arn,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-moderated-channel",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("app-instance-user-arn" => app_instance_user_arn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_moderator(channel_arn, channel_moderator_arn)
describe_channel_moderator(channel_arn, channel_moderator_arn, params::Dict{String,<:Any})
Returns the full details of a single ChannelModerator. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header. This API is is no longer supported and will not be updated. We
recommend using the latest version, DescribeChannelModerator, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `channel_moderator_arn`: The ARN of the channel moderator.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function describe_channel_moderator(
channelArn, channelModeratorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_moderator(
channelArn,
channelModeratorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_phone_number_from_user(account_id, user_id)
disassociate_phone_number_from_user(account_id, user_id, params::Dict{String,<:Any})
Disassociates the primary provisioned phone number from the specified Amazon Chime user.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function disassociate_phone_number_from_user(
accountId, userId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=disassociate-phone-number";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_phone_number_from_user(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=disassociate-phone-number",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_phone_numbers_from_voice_connector(e164_phone_numbers, voice_connector_id)
disassociate_phone_numbers_from_voice_connector(e164_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Disassociates the specified phone numbers from the specified Amazon Chime Voice Connector.
This API is is no longer supported and will not be updated. We recommend using the latest
version, DisassociatePhoneNumbersFromVoiceConnector, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function disassociate_phone_numbers_from_voice_connector(
E164PhoneNumbers, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=disassociate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_phone_numbers_from_voice_connector(
E164PhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=disassociate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_phone_numbers_from_voice_connector_group(e164_phone_numbers, voice_connector_group_id)
disassociate_phone_numbers_from_voice_connector_group(e164_phone_numbers, voice_connector_group_id, params::Dict{String,<:Any})
Disassociates the specified phone numbers from the specified Amazon Chime Voice Connector
group. This API is is no longer supported and will not be updated. We recommend using the
latest version, DisassociatePhoneNumbersFromVoiceConnectorGroup, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_group_id`: The Amazon Chime Voice Connector group ID.
"""
function disassociate_phone_numbers_from_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=disassociate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_phone_numbers_from_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=disassociate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_signin_delegate_groups_from_account(group_names, account_id)
disassociate_signin_delegate_groups_from_account(group_names, account_id, params::Dict{String,<:Any})
Disassociates the specified sign-in delegate groups from the specified Amazon Chime account.
# Arguments
- `group_names`: The sign-in delegate group names.
- `account_id`: The Amazon Chime account ID.
"""
function disassociate_signin_delegate_groups_from_account(
GroupNames, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)?operation=disassociate-signin-delegate-groups",
Dict{String,Any}("GroupNames" => GroupNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_signin_delegate_groups_from_account(
GroupNames,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)?operation=disassociate-signin-delegate-groups",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("GroupNames" => GroupNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account(account_id)
get_account(account_id, params::Dict{String,<:Any})
Retrieves details for the specified Amazon Chime account, such as account type and
supported licenses.
# Arguments
- `account_id`: The Amazon Chime account ID.
"""
function get_account(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_account(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account_settings(account_id)
get_account_settings(account_id, params::Dict{String,<:Any})
Retrieves account settings for the specified Amazon Chime account ID, such as remote
control and dialout settings. For more information about these settings, see Use the
Policies Page in the Amazon Chime Administration Guide.
# Arguments
- `account_id`: The Amazon Chime account ID.
"""
function get_account_settings(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_account_settings(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app_instance_retention_settings(app_instance_arn)
get_app_instance_retention_settings(app_instance_arn, params::Dict{String,<:Any})
Gets the retention settings for an AppInstance. This API is is no longer supported and
will not be updated. We recommend using the latest version, GetMessagingRetentionSettings,
in the Amazon Chime SDK. Using the latest version requires migrating to a dedicated
namespace. For more information, refer to Migrating from the Amazon Chime namespace in the
Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function get_app_instance_retention_settings(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/retention-settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_app_instance_retention_settings(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/retention-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app_instance_streaming_configurations(app_instance_arn)
get_app_instance_streaming_configurations(app_instance_arn, params::Dict{String,<:Any})
Gets the streaming settings for an AppInstance. This API is is no longer supported and
will not be updated. We recommend using the latest version,
GetMessagingStreamingConfigurations, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function get_app_instance_streaming_configurations(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/streaming-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_app_instance_streaming_configurations(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/streaming-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_attendee(attendee_id, meeting_id)
get_attendee(attendee_id, meeting_id, params::Dict{String,<:Any})
Gets the Amazon Chime SDK attendee details for a specified meeting ID and attendee ID. For
more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon
Chime SDK Developer Guide. This API is is no longer supported and will not be updated.
We recommend using the latest version, GetAttendee, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function get_attendee(
attendeeId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/meetings/$(meetingId)/attendees/$(attendeeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_attendee(
attendeeId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/meetings/$(meetingId)/attendees/$(attendeeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_bot(account_id, bot_id)
get_bot(account_id, bot_id, params::Dict{String,<:Any})
Retrieves details for the specified bot, such as bot email address, bot type, status, and
display name.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
"""
function get_bot(accountId, botId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/bots/$(botId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_bot(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/bots/$(botId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_channel_message(channel_arn, message_id)
get_channel_message(channel_arn, message_id, params::Dict{String,<:Any})
Gets the full details of a channel message. The x-amz-chime-bearer request header is
mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in
the header. This API is is no longer supported and will not be updated. We recommend
using the latest version, GetChannelMessage, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID of the message.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function get_channel_message(
channelArn, messageId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/messages/$(messageId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_channel_message(
channelArn,
messageId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/messages/$(messageId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_events_configuration(account_id, bot_id)
get_events_configuration(account_id, bot_id, params::Dict{String,<:Any})
Gets details for an events configuration that allows a bot to receive outgoing events, such
as an HTTPS endpoint or Lambda function ARN.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
"""
function get_events_configuration(
accountId, botId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/accounts/$(accountId)/bots/$(botId)/events-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_events_configuration(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/bots/$(botId)/events-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_global_settings()
get_global_settings(params::Dict{String,<:Any})
Retrieves global settings for the administrator's AWS account, such as Amazon Chime
Business Calling and Amazon Chime Voice Connector settings.
"""
function get_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime("GET", "/settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function get_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET", "/settings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_media_capture_pipeline(media_pipeline_id)
get_media_capture_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Gets an existing media capture pipeline. This API is is no longer supported and will not
be updated. We recommend using the latest version, GetMediaCapturePipeline, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `media_pipeline_id`: The ID of the pipeline that you want to get.
"""
function get_media_capture_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/media-capture-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_media_capture_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/media-capture-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_meeting(meeting_id)
get_meeting(meeting_id, params::Dict{String,<:Any})
This API is is no longer supported and will not be updated. We recommend using the latest
version, GetMeeting, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide. Gets the Amazon Chime SDK meeting
details for the specified meeting ID. For more information about the Amazon Chime SDK, see
Using the Amazon Chime SDK in the Amazon Chime SDK Developer Guide .
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function get_meeting(meetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/meetings/$(meetingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_meeting(
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/meetings/$(meetingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_messaging_session_endpoint()
get_messaging_session_endpoint(params::Dict{String,<:Any})
The details of the endpoint for the messaging session. This API is is no longer supported
and will not be updated. We recommend using the latest version,
GetMessagingSessionEndpoint, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
"""
function get_messaging_session_endpoint(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/endpoints/messaging-session";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_messaging_session_endpoint(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/endpoints/messaging-session",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_phone_number(phone_number_id)
get_phone_number(phone_number_id, params::Dict{String,<:Any})
Retrieves details for the specified phone number ID, such as associations, capabilities,
and product type.
# Arguments
- `phone_number_id`: The phone number ID.
"""
function get_phone_number(phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_phone_number_order(phone_number_order_id)
get_phone_number_order(phone_number_order_id, params::Dict{String,<:Any})
Retrieves details for the specified phone number order, such as the order creation
timestamp, phone numbers in E.164 format, product type, and order status.
# Arguments
- `phone_number_order_id`: The ID for the phone number order.
"""
function get_phone_number_order(
phoneNumberOrderId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/phone-number-orders/$(phoneNumberOrderId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number_order(
phoneNumberOrderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/phone-number-orders/$(phoneNumberOrderId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_phone_number_settings()
get_phone_number_settings(params::Dict{String,<:Any})
Retrieves the phone number settings for the administrator's AWS account, such as the
default outbound calling name.
"""
function get_phone_number_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/settings/phone-number";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/settings/phone-number",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_proxy_session(proxy_session_id, voice_connector_id)
get_proxy_session(proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Gets the specified proxy session details for the specified Amazon Chime Voice Connector.
This API is is no longer supported and will not be updated. We recommend using the latest
version, GetProxySession, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Amazon Chime voice connector ID.
"""
function get_proxy_session(
proxySessionId, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_proxy_session(
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_retention_settings(account_id)
get_retention_settings(account_id, params::Dict{String,<:Any})
Gets the retention settings for the specified Amazon Chime Enterprise account. For more
information about retention settings, see Managing Chat Retention Policies in the Amazon
Chime Administration Guide.
# Arguments
- `account_id`: The Amazon Chime account ID.
"""
function get_retention_settings(
accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/accounts/$(accountId)/retention-settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_retention_settings(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/retention-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_room(account_id, room_id)
get_room(account_id, room_id, params::Dict{String,<:Any})
Retrieves room details, such as the room name, for a room in an Amazon Chime Enterprise
account.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `room_id`: The room ID.
"""
function get_room(accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/rooms/$(roomId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_room(
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/rooms/$(roomId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_media_application(sip_media_application_id)
get_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Retrieves the information for a SIP media application, including name, AWS Region, and
endpoints. This API is is no longer supported and will not be updated. We recommend using
the latest version, GetSipMediaApplication, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function get_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_media_application_logging_configuration(sip_media_application_id)
get_sip_media_application_logging_configuration(sip_media_application_id, params::Dict{String,<:Any})
Returns the logging configuration for the specified SIP media application. This API is is
no longer supported and will not be updated. We recommend using the latest version,
GetSipMediaApplicationLoggingConfiguration, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function get_sip_media_application_logging_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_media_application_logging_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_rule(sip_rule_id)
get_sip_rule(sip_rule_id, params::Dict{String,<:Any})
Retrieves the details of a SIP rule, such as the rule ID, name, triggers, and target
endpoints. This API is is no longer supported and will not be updated. We recommend using
the latest version, GetSipRule, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_rule_id`: The SIP rule ID.
"""
function get_sip_rule(sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/sip-rules/$(sipRuleId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_rule(
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/sip-rules/$(sipRuleId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_user(account_id, user_id)
get_user(account_id, user_id, params::Dict{String,<:Any})
Retrieves details for the specified user ID, such as primary email address, license
type,and personal meeting PIN. To retrieve user details with an email address instead of a
user ID, use the ListUsers action, and then filter by email address.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function get_user(accountId, userId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/users/$(userId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_user(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/users/$(userId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_user_settings(account_id, user_id)
get_user_settings(account_id, user_id, params::Dict{String,<:Any})
Retrieves settings for the specified user ID, such as any associated phone number settings.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function get_user_settings(
accountId, userId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/accounts/$(accountId)/users/$(userId)/settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_user_settings(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/users/$(userId)/settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector(voice_connector_id)
get_voice_connector(voice_connector_id, params::Dict{String,<:Any})
Retrieves details for the specified Amazon Chime Voice Connector, such as timestamps,name,
outbound host, and encryption requirements. This API is is no longer supported and will
not be updated. We recommend using the latest version, GetVoiceConnector, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_emergency_calling_configuration(voice_connector_id)
get_voice_connector_emergency_calling_configuration(voice_connector_id, params::Dict{String,<:Any})
Gets the emergency calling configuration details for the specified Amazon Chime Voice
Connector. This API is is no longer supported and will not be updated. We recommend using
the latest version, GetVoiceConnectorEmergencyCallingConfiguration, in the Amazon Chime
SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_emergency_calling_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_emergency_calling_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_group(voice_connector_group_id)
get_voice_connector_group(voice_connector_group_id, params::Dict{String,<:Any})
Retrieves details for the specified Amazon Chime Voice Connector group, such as
timestamps,name, and associated VoiceConnectorItems. This API is is no longer supported
and will not be updated. We recommend using the latest version, GetVoiceConnectorGroup, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `voice_connector_group_id`: The Amazon Chime Voice Connector group ID.
"""
function get_voice_connector_group(
voiceConnectorGroupId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connector-groups/$(voiceConnectorGroupId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_group(
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connector-groups/$(voiceConnectorGroupId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_logging_configuration(voice_connector_id)
get_voice_connector_logging_configuration(voice_connector_id, params::Dict{String,<:Any})
Retrieves the logging configuration details for the specified Amazon Chime Voice Connector.
Shows whether SIP message logs are enabled for sending to Amazon CloudWatch Logs. This
API is is no longer supported and will not be updated. We recommend using the latest
version, GetVoiceConnectorLoggingConfiguration, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_logging_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_logging_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_origination(voice_connector_id)
get_voice_connector_origination(voice_connector_id, params::Dict{String,<:Any})
Retrieves origination setting details for the specified Amazon Chime Voice Connector.
This API is is no longer supported and will not be updated. We recommend using the latest
version, GetVoiceConnectorOrigination, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_origination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/origination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_origination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/origination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_proxy(voice_connector_id)
get_voice_connector_proxy(voice_connector_id, params::Dict{String,<:Any})
Gets the proxy configuration details for the specified Amazon Chime Voice Connector. This
API is is no longer supported and will not be updated. We recommend using the latest
version, GetVoiceConnectorProxy, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime voice connector ID.
"""
function get_voice_connector_proxy(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_proxy(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_streaming_configuration(voice_connector_id)
get_voice_connector_streaming_configuration(voice_connector_id, params::Dict{String,<:Any})
Retrieves the streaming configuration details for the specified Amazon Chime Voice
Connector. Shows whether media streaming is enabled for sending to Amazon Kinesis. It also
shows the retention period, in hours, for the Amazon Kinesis data. This API is is no
longer supported and will not be updated. We recommend using the latest version,
GetVoiceConnectorStreamingConfiguration, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_streaming_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_streaming_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_termination(voice_connector_id)
get_voice_connector_termination(voice_connector_id, params::Dict{String,<:Any})
Retrieves termination setting details for the specified Amazon Chime Voice Connector.
This API is is no longer supported and will not be updated. We recommend using the latest
version, GetVoiceConnectorTermination, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_termination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_termination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_termination_health(voice_connector_id)
get_voice_connector_termination_health(voice_connector_id, params::Dict{String,<:Any})
This API is is no longer supported and will not be updated. We recommend using the latest
version, GetVoiceConnectorTerminationHealth, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
Retrieves information about the last time a SIP OPTIONS ping was received from your SIP
infrastructure for the specified Amazon Chime Voice Connector.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function get_voice_connector_termination_health(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/health";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_termination_health(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/health",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
invite_users(user_email_list, account_id)
invite_users(user_email_list, account_id, params::Dict{String,<:Any})
Sends email to a maximum of 50 users, inviting them to the specified Amazon Chime Team
account. Only Team account types are currently supported for this action.
# Arguments
- `user_email_list`: The user email addresses to which to send the email invitation.
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"UserType"`: The user type.
"""
function invite_users(
UserEmailList, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=add",
Dict{String,Any}("UserEmailList" => UserEmailList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function invite_users(
UserEmailList,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users?operation=add",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("UserEmailList" => UserEmailList), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_accounts()
list_accounts(params::Dict{String,<:Any})
Lists the Amazon Chime accounts under the administrator's AWS account. You can filter
accounts by account name prefix. To find out which Amazon Chime account a user belongs to,
you can filter by the user's email address, which returns one account result.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"name"`: Amazon Chime account name prefix with which to filter results.
- `"next-token"`: The token to use to retrieve the next page of results.
- `"user-email"`: User email address with which to filter results.
"""
function list_accounts(; aws_config::AbstractAWSConfig=global_aws_config())
return chime("GET", "/accounts"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_accounts(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET", "/accounts", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_app_instance_admins(app_instance_arn)
list_app_instance_admins(app_instance_arn, params::Dict{String,<:Any})
Returns a list of the administrators in the AppInstance. This API is is no longer
supported and will not be updated. We recommend using the latest version,
ListAppInstanceAdmins, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of administrators that you want to return.
- `"next-token"`: The token returned from previous API requests until the number of
administrators is reached.
"""
function list_app_instance_admins(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/admins";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_admins(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instances/$(appInstanceArn)/admins",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instance_users(app-instance-arn)
list_app_instance_users(app-instance-arn, params::Dict{String,<:Any})
List all AppInstanceUsers created under a single AppInstance. This API is is no longer
supported and will not be updated. We recommend using the latest version,
ListAppInstanceUsers, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app-instance-arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of requests that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested users are
returned.
"""
function list_app_instance_users(
app_instance_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instance-users",
Dict{String,Any}("app-instance-arn" => app_instance_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_users(
app_instance_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/app-instance-users",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("app-instance-arn" => app_instance_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instances()
list_app_instances(params::Dict{String,<:Any})
Lists all Amazon Chime AppInstances created under a single AWS account. This API is is no
longer supported and will not be updated. We recommend using the latest version,
ListAppInstances, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of AppInstances that you want to return.
- `"next-token"`: The token passed by previous API requests until you reach the maximum
number of AppInstances.
"""
function list_app_instances(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET", "/app-instances"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_app_instances(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/app-instances",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_attendee_tags(attendee_id, meeting_id)
list_attendee_tags(attendee_id, meeting_id, params::Dict{String,<:Any})
Lists the tags applied to an Amazon Chime SDK attendee resource. ListAttendeeTags is not
supported in the Amazon Chime SDK Meetings Namespace. Update your application to remove
calls to this API.
# Arguments
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function list_attendee_tags(
attendeeId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_attendee_tags(
attendeeId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_attendees(meeting_id)
list_attendees(meeting_id, params::Dict{String,<:Any})
Lists the attendees for the specified Amazon Chime SDK meeting. For more information about
the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime SDK Developer
Guide. This API is is no longer supported and will not be updated. We recommend using
the latest version, ListAttendees, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_attendees(meetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/meetings/$(meetingId)/attendees";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_attendees(
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/meetings/$(meetingId)/attendees",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_bots(account_id)
list_bots(account_id, params::Dict{String,<:Any})
Lists the bots associated with the administrator's Amazon Chime Enterprise account ID.
# Arguments
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. The default is
10.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_bots(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/bots";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_bots(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/bots",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_bans(channel_arn)
list_channel_bans(channel_arn, params::Dict{String,<:Any})
Lists all the users banned from a particular channel. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header. This API is is no longer supported and will not be updated. We
recommend using the latest version, ListChannelBans, in the Amazon Chime SDK. Using the
latest version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of bans that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested bans are
returned.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channel_bans(channelArn; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/channels/$(channelArn)/bans";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_bans(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/bans",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_memberships(channel_arn)
list_channel_memberships(channel_arn, params::Dict{String,<:Any})
Lists all channel memberships in a channel. The x-amz-chime-bearer request header is
mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in
the header. This API is is no longer supported and will not be updated. We recommend
using the latest version, ListChannelMemberships, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The maximum number of channel memberships that you want returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channel memberships that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested channel
memberships are returned.
- `"type"`: The membership type of a user, DEFAULT or HIDDEN. Default members are always
returned as part of ListChannelMemberships. Hidden members are only returned if the type
filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channel_memberships(
channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/memberships";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_memberships(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/memberships",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_memberships_for_app_instance_user()
list_channel_memberships_for_app_instance_user(params::Dict{String,<:Any})
Lists all channels that a particular AppInstanceUser is a part of. Only an
AppInstanceAdmin can call the API with a user ARN that is not their own. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version,
ListChannelMembershipsForAppInstanceUser, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"app-instance-user-arn"`: The ARN of the AppInstanceUsers
- `"max-results"`: The maximum number of users that you want returned.
- `"next-token"`: The token returned from previous API requests until the number of channel
memberships is reached.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channel_memberships_for_app_instance_user(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels?scope=app-instance-user-memberships";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_memberships_for_app_instance_user(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels?scope=app-instance-user-memberships",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_messages(channel_arn)
list_channel_messages(channel_arn, params::Dict{String,<:Any})
List all the messages in a channel. Returns a paginated list of ChannelMessages. By
default, sorted by creation timestamp in descending order. Redacted messages appear in the
results as empty, since they are only redacted, not deleted. Deleted messages do not appear
in the results. This action always returns the latest version of an edited message. Also,
the x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user
that makes the API call as the value in the header. This API is is no longer supported
and will not be updated. We recommend using the latest version, ListChannelMessages, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of messages that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested messages are
returned.
- `"not-after"`: The final or ending time stamp for your requested messages.
- `"not-before"`: The initial or starting time stamp for your requested messages.
- `"sort-order"`: The order in which you want messages sorted. Default is Descending, based
on time created.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channel_messages(
channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/messages";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_messages(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/messages",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_moderators(channel_arn)
list_channel_moderators(channel_arn, params::Dict{String,<:Any})
Lists all the moderators for a channel. The x-amz-chime-bearer request header is
mandatory. Use the AppInstanceUserArn of the user that makes the API call as the value in
the header. This API is is no longer supported and will not be updated. We recommend
using the latest version, ListChannelModerators, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of moderators that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested moderators are
returned.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channel_moderators(
channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels/$(channelArn)/moderators";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_moderators(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels/$(channelArn)/moderators",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels(app-instance-arn)
list_channels(app-instance-arn, params::Dict{String,<:Any})
Lists all Channels created under a single Chime App as a paginated list. You can specify
filters to narrow results. Functionality & restrictions Use privacy = PUBLIC to
retrieve all public channels in the account. Only an AppInstanceAdmin can set privacy =
PRIVATE to list the private channels in an account. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header. This API is is no longer supported and will not be updated. We
recommend using the latest version, ListChannels, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app-instance-arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channels that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested channels are
returned.
- `"privacy"`: The privacy setting. PUBLIC retrieves all the public channels. PRIVATE
retrieves private channels. Only an AppInstanceAdmin can retrieve private channels.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channels(app_instance_arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/channels",
Dict{String,Any}("app-instance-arn" => app_instance_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channels(
app_instance_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/channels",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("app-instance-arn" => app_instance_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels_moderated_by_app_instance_user()
list_channels_moderated_by_app_instance_user(params::Dict{String,<:Any})
A list of the channels moderated by an AppInstanceUser. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header. This API is is no longer supported and will not be updated. We
recommend using the latest version, ListChannelsModeratedByAppInstanceUser, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"app-instance-user-arn"`: The ARN of the user in the moderated channel.
- `"max-results"`: The maximum number of channels in the request.
- `"next-token"`: The token returned from previous API requests until the number of
channels moderated by the user is reached.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function list_channels_moderated_by_app_instance_user(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels?scope=app-instance-user-moderated-channels";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channels_moderated_by_app_instance_user(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/channels?scope=app-instance-user-moderated-channels",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_media_capture_pipelines()
list_media_capture_pipelines(params::Dict{String,<:Any})
Returns a list of media capture pipelines. This API is is no longer supported and will
not be updated. We recommend using the latest version, ListMediaCapturePipelines, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Valid Range: 1
- 99.
- `"next-token"`: The token used to retrieve the next page of results.
"""
function list_media_capture_pipelines(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/media-capture-pipelines";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_media_capture_pipelines(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/media-capture-pipelines",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_meeting_tags(meeting_id)
list_meeting_tags(meeting_id, params::Dict{String,<:Any})
Lists the tags applied to an Amazon Chime SDK meeting resource. This API is is no longer
supported and will not be updated. We recommend using the latest version,
ListTagsForResource, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function list_meeting_tags(meetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/meetings/$(meetingId)/tags";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_meeting_tags(
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/meetings/$(meetingId)/tags",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_meetings()
list_meetings(params::Dict{String,<:Any})
Lists up to 100 active Amazon Chime SDK meetings. ListMeetings is not supported in the
Amazon Chime SDK Meetings Namespace. Update your application to remove calls to this API.
For more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the
Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_meetings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime("GET", "/meetings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_meetings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET", "/meetings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_phone_number_orders()
list_phone_number_orders(params::Dict{String,<:Any})
Lists the phone number orders for the administrator's Amazon Chime account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_phone_number_orders(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/phone-number-orders";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_phone_number_orders(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/phone-number-orders",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_phone_numbers()
list_phone_numbers(params::Dict{String,<:Any})
Lists the phone numbers for the specified Amazon Chime account, Amazon Chime user, Amazon
Chime Voice Connector, or Amazon Chime Voice Connector group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter-name"`: The filter to use to limit the number of results.
- `"filter-value"`: The value to use for the filter.
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
- `"product-type"`: The phone number product type.
- `"status"`: The phone number status.
"""
function list_phone_numbers(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET", "/phone-numbers"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_phone_numbers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/phone-numbers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_proxy_sessions(voice_connector_id)
list_proxy_sessions(voice_connector_id, params::Dict{String,<:Any})
Lists the proxy sessions for the specified Amazon Chime Voice Connector. This API is is
no longer supported and will not be updated. We recommend using the latest version,
ListProxySessions, in the Amazon Chime SDK. Using the latest version requires migrating to
a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime voice connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
- `"status"`: The proxy session status.
"""
function list_proxy_sessions(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_proxy_sessions(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_room_memberships(account_id, room_id)
list_room_memberships(account_id, room_id, params::Dict{String,<:Any})
Lists the membership details for the specified room in an Amazon Chime Enterprise account,
such as the members' IDs, email addresses, and names.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `room_id`: The room ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_room_memberships(
accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/accounts/$(accountId)/rooms/$(roomId)/memberships";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_room_memberships(
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/rooms/$(roomId)/memberships",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_rooms(account_id)
list_rooms(account_id, params::Dict{String,<:Any})
Lists the room details for the specified Amazon Chime Enterprise account. Optionally,
filter the results by a member ID (user ID or bot ID) to see a list of rooms that the
member belongs to.
# Arguments
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"member-id"`: The member ID (user ID or bot ID).
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_rooms(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/rooms";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_rooms(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/rooms",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sip_media_applications()
list_sip_media_applications(params::Dict{String,<:Any})
Lists the SIP media applications under the administrator's AWS account. This API is is no
longer supported and will not be updated. We recommend using the latest version,
ListSipMediaApplications, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_sip_media_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/sip-media-applications";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sip_media_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/sip-media-applications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sip_rules()
list_sip_rules(params::Dict{String,<:Any})
Lists the SIP rules under the administrator's AWS account. This API is is no longer
supported and will not be updated. We recommend using the latest version, ListSipRules, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"next-token"`: The token to use to retrieve the next page of results.
- `"sip-media-application"`: The SIP media application ID.
"""
function list_sip_rules(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET", "/sip-rules"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_sip_rules(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET", "/sip-rules", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_supported_phone_number_countries(product-type)
list_supported_phone_number_countries(product-type, params::Dict{String,<:Any})
Lists supported phone number countries.
# Arguments
- `product-type`: The phone number product type.
"""
function list_supported_phone_number_countries(
product_type; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/phone-number-countries",
Dict{String,Any}("product-type" => product_type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_supported_phone_number_countries(
product_type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/phone-number-countries",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("product-type" => product_type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Lists the tags applied to an Amazon Chime SDK meeting and messaging resources. This API
is is no longer supported and will not be updated. We recommend using the applicable latest
version in the Amazon Chime SDK. For meetings: ListTagsForResource. For messaging:
ListTagsForResource. Using the latest version requires migrating to a dedicated
namespace. For more information, refer to Migrating from the Amazon Chime namespace in the
Amazon Chime SDK Developer Guide.
# Arguments
- `arn`: The resource ARN.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_users(account_id)
list_users(account_id, params::Dict{String,<:Any})
Lists the users that belong to the specified Amazon Chime account. You can specify an email
address to list only the user that the email address belongs to.
# Arguments
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"next-token"`: The token to use to retrieve the next page of results.
- `"user-email"`: Optional. The user email address used to filter results. Maximum 1.
- `"user-type"`: The user type.
"""
function list_users(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/accounts/$(accountId)/users";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_users(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/accounts/$(accountId)/users",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connector_groups()
list_voice_connector_groups(params::Dict{String,<:Any})
Lists the Amazon Chime Voice Connector groups for the administrator's AWS account. This
API is is no longer supported and will not be updated. We recommend using the latest
version, ListVoiceConnectorGroups, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_voice_connector_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/voice-connector-groups";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_connector_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connector-groups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connector_termination_credentials(voice_connector_id)
list_voice_connector_termination_credentials(voice_connector_id, params::Dict{String,<:Any})
Lists the SIP credentials for the specified Amazon Chime Voice Connector. This API is is
no longer supported and will not be updated. We recommend using the latest version,
ListVoiceConnectorTerminationCredentials, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function list_voice_connector_termination_credentials(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/credentials";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_connector_termination_credentials(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/credentials",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connectors()
list_voice_connectors(params::Dict{String,<:Any})
Lists the Amazon Chime Voice Connectors for the administrator's AWS account. This API is
is no longer supported and will not be updated. We recommend using the latest version,
ListVoiceConnectors, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_voice_connectors(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET", "/voice-connectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_voice_connectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/voice-connectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
logout_user(account_id, user_id)
logout_user(account_id, user_id, params::Dict{String,<:Any})
Logs out the specified user from all of the devices they are currently logged into.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function logout_user(accountId, userId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=logout";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function logout_user(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=logout",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_app_instance_retention_settings(app_instance_retention_settings, app_instance_arn)
put_app_instance_retention_settings(app_instance_retention_settings, app_instance_arn, params::Dict{String,<:Any})
Sets the amount of time in days that a given AppInstance retains data. This API is is no
longer supported and will not be updated. We recommend using the latest version,
PutAppInstanceRetentionSettings, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_retention_settings`: The time in days to retain data. Data type: number.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function put_app_instance_retention_settings(
AppInstanceRetentionSettings,
appInstanceArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)/retention-settings",
Dict{String,Any}("AppInstanceRetentionSettings" => AppInstanceRetentionSettings);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_app_instance_retention_settings(
AppInstanceRetentionSettings,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)/retention-settings",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceRetentionSettings" => AppInstanceRetentionSettings
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_app_instance_streaming_configurations(app_instance_streaming_configurations, app_instance_arn)
put_app_instance_streaming_configurations(app_instance_streaming_configurations, app_instance_arn, params::Dict{String,<:Any})
The data streaming configurations of an AppInstance. This API is is no longer supported
and will not be updated. We recommend using the latest version,
PutMessagingStreamingConfigurations, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_streaming_configurations`: The streaming configurations set for an
AppInstance.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function put_app_instance_streaming_configurations(
AppInstanceStreamingConfigurations,
appInstanceArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)/streaming-configurations",
Dict{String,Any}(
"AppInstanceStreamingConfigurations" => AppInstanceStreamingConfigurations
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_app_instance_streaming_configurations(
AppInstanceStreamingConfigurations,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)/streaming-configurations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceStreamingConfigurations" =>
AppInstanceStreamingConfigurations,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_events_configuration(account_id, bot_id)
put_events_configuration(account_id, bot_id, params::Dict{String,<:Any})
Creates an events configuration that allows a bot to receive outgoing events sent by Amazon
Chime. Choose either an HTTPS endpoint or a Lambda function ARN. For more information, see
Bot.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LambdaFunctionArn"`: Lambda function ARN that allows the bot to receive outgoing events.
- `"OutboundEventsHTTPSEndpoint"`: HTTPS endpoint that allows the bot to receive outgoing
events.
"""
function put_events_configuration(
accountId, botId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/accounts/$(accountId)/bots/$(botId)/events-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_events_configuration(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/accounts/$(accountId)/bots/$(botId)/events-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_retention_settings(retention_settings, account_id)
put_retention_settings(retention_settings, account_id, params::Dict{String,<:Any})
Puts retention settings for the specified Amazon Chime Enterprise account. We recommend
using AWS CloudTrail to monitor usage of this API for your account. For more information,
see Logging Amazon Chime API Calls with AWS CloudTrail in the Amazon Chime Administration
Guide. To turn off existing retention settings, remove the number of days from the
corresponding RetentionDays field in the RetentionSettings object. For more information
about retention settings, see Managing Chat Retention Policies in the Amazon Chime
Administration Guide.
# Arguments
- `retention_settings`: The retention settings.
- `account_id`: The Amazon Chime account ID.
"""
function put_retention_settings(
RetentionSettings, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/accounts/$(accountId)/retention-settings",
Dict{String,Any}("RetentionSettings" => RetentionSettings);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_retention_settings(
RetentionSettings,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/accounts/$(accountId)/retention-settings",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RetentionSettings" => RetentionSettings), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_sip_media_application_logging_configuration(sip_media_application_id)
put_sip_media_application_logging_configuration(sip_media_application_id, params::Dict{String,<:Any})
Updates the logging configuration for the specified SIP media application. This API is is
no longer supported and will not be updated. We recommend using the latest version,
PutSipMediaApplicationLoggingConfiguration, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SipMediaApplicationLoggingConfiguration"`: The actual logging configuration.
"""
function put_sip_media_application_logging_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_sip_media_application_logging_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_emergency_calling_configuration(emergency_calling_configuration, voice_connector_id)
put_voice_connector_emergency_calling_configuration(emergency_calling_configuration, voice_connector_id, params::Dict{String,<:Any})
Puts emergency calling configuration details to the specified Amazon Chime Voice Connector,
such as emergency phone numbers and calling countries. Origination and termination settings
must be enabled for the Amazon Chime Voice Connector before emergency calling can be
configured. This API is is no longer supported and will not be updated. We recommend
using the latest version, PutVoiceConnectorEmergencyCallingConfiguration, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `emergency_calling_configuration`: The emergency calling configuration details.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function put_voice_connector_emergency_calling_configuration(
EmergencyCallingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
Dict{String,Any}("EmergencyCallingConfiguration" => EmergencyCallingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_emergency_calling_configuration(
EmergencyCallingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EmergencyCallingConfiguration" => EmergencyCallingConfiguration
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_logging_configuration(logging_configuration, voice_connector_id)
put_voice_connector_logging_configuration(logging_configuration, voice_connector_id, params::Dict{String,<:Any})
Adds a logging configuration for the specified Amazon Chime Voice Connector. The logging
configuration specifies whether SIP message logs are enabled for sending to Amazon
CloudWatch Logs. This API is is no longer supported and will not be updated. We recommend
using the latest version, PutVoiceConnectorLoggingConfiguration, in the Amazon Chime SDK.
Using the latest version requires migrating to a dedicated namespace. For more information,
refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `logging_configuration`: The logging configuration details to add.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function put_voice_connector_logging_configuration(
LoggingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
Dict{String,Any}("LoggingConfiguration" => LoggingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_logging_configuration(
LoggingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("LoggingConfiguration" => LoggingConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_origination(origination, voice_connector_id)
put_voice_connector_origination(origination, voice_connector_id, params::Dict{String,<:Any})
Adds origination settings for the specified Amazon Chime Voice Connector. If emergency
calling is configured for the Amazon Chime Voice Connector, it must be deleted prior to
turning off origination settings. This API is is no longer supported and will not be
updated. We recommend using the latest version, PutVoiceConnectorOrigination, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `origination`: The origination setting details to add.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function put_voice_connector_origination(
Origination, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/origination",
Dict{String,Any}("Origination" => Origination);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_origination(
Origination,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/origination",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Origination" => Origination), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_proxy(default_session_expiry_minutes, phone_number_pool_countries, voice_connector_id)
put_voice_connector_proxy(default_session_expiry_minutes, phone_number_pool_countries, voice_connector_id, params::Dict{String,<:Any})
Puts the specified proxy configuration to the specified Amazon Chime Voice Connector.
This API is is no longer supported and will not be updated. We recommend using the latest
version, PutVoiceConnectorProxy, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `default_session_expiry_minutes`: The default number of minutes allowed for proxy
sessions.
- `phone_number_pool_countries`: The countries for proxy phone numbers to be selected from.
- `voice_connector_id`: The Amazon Chime voice connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: When true, stops proxy sessions from being created on the specified Amazon
Chime Voice Connector.
- `"FallBackPhoneNumber"`: The phone number to route calls to after a proxy session expires.
"""
function put_voice_connector_proxy(
DefaultSessionExpiryMinutes,
PhoneNumberPoolCountries,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
Dict{String,Any}(
"DefaultSessionExpiryMinutes" => DefaultSessionExpiryMinutes,
"PhoneNumberPoolCountries" => PhoneNumberPoolCountries,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_proxy(
DefaultSessionExpiryMinutes,
PhoneNumberPoolCountries,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DefaultSessionExpiryMinutes" => DefaultSessionExpiryMinutes,
"PhoneNumberPoolCountries" => PhoneNumberPoolCountries,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_streaming_configuration(streaming_configuration, voice_connector_id)
put_voice_connector_streaming_configuration(streaming_configuration, voice_connector_id, params::Dict{String,<:Any})
Adds a streaming configuration for the specified Amazon Chime Voice Connector. The
streaming configuration specifies whether media streaming is enabled for sending to
Kinesis. It also sets the retention period, in hours, for the Amazon Kinesis data. This
API is is no longer supported and will not be updated. We recommend using the latest
version, PutVoiceConnectorStreamingConfiguration, in the Amazon Chime SDK. Using the latest
version requires migrating to a dedicated namespace. For more information, refer to
Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `streaming_configuration`: The streaming configuration details to add.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function put_voice_connector_streaming_configuration(
StreamingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
Dict{String,Any}("StreamingConfiguration" => StreamingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_streaming_configuration(
StreamingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("StreamingConfiguration" => StreamingConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_termination(termination, voice_connector_id)
put_voice_connector_termination(termination, voice_connector_id, params::Dict{String,<:Any})
Adds termination settings for the specified Amazon Chime Voice Connector. If emergency
calling is configured for the Amazon Chime Voice Connector, it must be deleted prior to
turning off termination settings. This API is is no longer supported and will not be
updated. We recommend using the latest version, PutVoiceConnectorTermination, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `termination`: The termination setting details to add.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function put_voice_connector_termination(
Termination, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/termination",
Dict{String,Any}("Termination" => Termination);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_termination(
Termination,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)/termination",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Termination" => Termination), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_termination_credentials(voice_connector_id)
put_voice_connector_termination_credentials(voice_connector_id, params::Dict{String,<:Any})
Adds termination SIP credentials for the specified Amazon Chime Voice Connector. This API
is is no longer supported and will not be updated. We recommend using the latest version,
PutVoiceConnectorTerminationCredentials, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Credentials"`: The termination SIP credentials.
"""
function put_voice_connector_termination_credentials(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=put";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_termination_credentials(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=put",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
redact_channel_message(channel_arn, message_id)
redact_channel_message(channel_arn, message_id, params::Dict{String,<:Any})
Redacts message content, but not metadata. The message exists in the back end, but the
action returns null content, and the state shows as redacted. The x-amz-chime-bearer
request header is mandatory. Use the AppInstanceUserArn of the user that makes the API call
as the value in the header. This API is is no longer supported and will not be updated.
We recommend using the latest version, RedactChannelMessage, in the Amazon Chime SDK. Using
the latest version requires migrating to a dedicated namespace. For more information, refer
to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel containing the messages that you want to redact.
- `message_id`: The ID of the message being redacted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function redact_channel_message(
channelArn, messageId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/channels/$(channelArn)/messages/$(messageId)?operation=redact";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function redact_channel_message(
channelArn,
messageId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/messages/$(messageId)?operation=redact",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
redact_conversation_message(account_id, conversation_id, message_id)
redact_conversation_message(account_id, conversation_id, message_id, params::Dict{String,<:Any})
Redacts the specified message from the specified Amazon Chime conversation.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `conversation_id`: The conversation ID.
- `message_id`: The message ID.
"""
function redact_conversation_message(
accountId, conversationId, messageId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/conversations/$(conversationId)/messages/$(messageId)?operation=redact";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function redact_conversation_message(
accountId,
conversationId,
messageId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/conversations/$(conversationId)/messages/$(messageId)?operation=redact",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
redact_room_message(account_id, message_id, room_id)
redact_room_message(account_id, message_id, room_id, params::Dict{String,<:Any})
Redacts the specified message from the specified Amazon Chime channel.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `message_id`: The message ID.
- `room_id`: The room ID.
"""
function redact_room_message(
accountId, messageId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/messages/$(messageId)?operation=redact";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function redact_room_message(
accountId,
messageId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/messages/$(messageId)?operation=redact",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
regenerate_security_token(account_id, bot_id)
regenerate_security_token(account_id, bot_id, params::Dict{String,<:Any})
Regenerates the security token for a bot.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
"""
function regenerate_security_token(
accountId, botId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/bots/$(botId)?operation=regenerate-security-token";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function regenerate_security_token(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/bots/$(botId)?operation=regenerate-security-token",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
reset_personal_pin(account_id, user_id)
reset_personal_pin(account_id, user_id, params::Dict{String,<:Any})
Resets the personal meeting PIN for the specified user on an Amazon Chime account. Returns
the User object with the updated personal meeting PIN.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function reset_personal_pin(
accountId, userId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=reset-personal-pin";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function reset_personal_pin(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)?operation=reset-personal-pin",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
restore_phone_number(phone_number_id)
restore_phone_number(phone_number_id, params::Dict{String,<:Any})
Moves a phone number from the Deletion queue back into the phone number Inventory.
# Arguments
- `phone_number_id`: The phone number.
"""
function restore_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/phone-numbers/$(phoneNumberId)?operation=restore";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function restore_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/phone-numbers/$(phoneNumberId)?operation=restore",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_available_phone_numbers()
search_available_phone_numbers(params::Dict{String,<:Any})
Searches for phone numbers that can be ordered. For US numbers, provide at least one of the
following search filters: AreaCode, City, State, or TollFreePrefix. If you provide City,
you must also provide State. Numbers outside the US only support the PhoneNumberType
filter, which you must use.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"area-code"`: The area code used to filter results. Only applies to the US.
- `"city"`: The city used to filter results. Only applies to the US.
- `"country"`: The country used to filter results. Defaults to the US Format: ISO 3166-1
alpha-2.
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to retrieve the next page of results.
- `"phone-number-type"`: The phone number type used to filter results. Required for non-US
numbers.
- `"state"`: The state used to filter results. Required only if you provide City. Only
applies to the US.
- `"toll-free-prefix"`: The toll-free prefix that you use to filter results. Only applies
to the US.
"""
function search_available_phone_numbers(; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"GET",
"/search?type=phone-numbers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_available_phone_numbers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"GET",
"/search?type=phone-numbers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
send_channel_message(client_request_token, content, persistence, type, channel_arn)
send_channel_message(client_request_token, content, persistence, type, channel_arn, params::Dict{String,<:Any})
Sends a message to a particular channel that the member is a part of. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. Also, STANDARD messages can contain 4KB of
data and the 1KB of metadata. CONTROL messages can contain 30 bytes of data and no
metadata. This API is is no longer supported and will not be updated. We recommend using
the latest version, SendChannelMessage, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `client_request_token`: The Idempotency token for each client request.
- `content`: The content of the message.
- `persistence`: Boolean that controls whether the message is persisted on the back end.
Required.
- `type`: The type of message, STANDARD or CONTROL.
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The optional metadata for each message.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function send_channel_message(
ClientRequestToken,
Content,
Persistence,
Type,
channelArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"Content" => Content,
"Persistence" => Persistence,
"Type" => Type,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function send_channel_message(
ClientRequestToken,
Content,
Persistence,
Type,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"Content" => Content,
"Persistence" => Persistence,
"Type" => Type,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_meeting_transcription(transcription_configuration, meeting_id)
start_meeting_transcription(transcription_configuration, meeting_id, params::Dict{String,<:Any})
Starts transcription for the specified meetingId. For more information, refer to Using
Amazon Chime SDK live transcription in the Amazon Chime SDK Developer Guide. If you
specify an invalid configuration, a TranscriptFailed event will be sent with the contents
of the BadRequestException generated by Amazon Transcribe. For more information on each
parameter and which combinations are valid, refer to the StartStreamTranscription API in
the Amazon Transcribe Developer Guide. Amazon Chime SDK live transcription is powered by
Amazon Transcribe. Use of Amazon Transcribe is subject to the AWS Service Terms, including
the terms specific to the AWS Machine Learning and Artificial Intelligence Services.
This API is is no longer supported and will not be updated. We recommend using the latest
version, StartMeetingTranscription, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `transcription_configuration`: The configuration for the current transcription operation.
Must contain EngineTranscribeSettings or EngineTranscribeMedicalSettings.
- `meeting_id`: The unique ID of the meeting being transcribed.
"""
function start_meeting_transcription(
TranscriptionConfiguration, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/transcription?operation=start",
Dict{String,Any}("TranscriptionConfiguration" => TranscriptionConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_meeting_transcription(
TranscriptionConfiguration,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/transcription?operation=start",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TranscriptionConfiguration" => TranscriptionConfiguration
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_meeting_transcription(meeting_id)
stop_meeting_transcription(meeting_id, params::Dict{String,<:Any})
Stops transcription for the specified meetingId. This API is is no longer supported and
will not be updated. We recommend using the latest version, StopMeetingTranscription, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `meeting_id`: The unique ID of the meeting for which you stop transcription.
"""
function stop_meeting_transcription(
meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/transcription?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_meeting_transcription(
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/transcription?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_attendee(tags, attendee_id, meeting_id)
tag_attendee(tags, attendee_id, meeting_id, params::Dict{String,<:Any})
Applies the specified tags to the specified Amazon Chime attendee. TagAttendee is not
supported in the Amazon Chime SDK Meetings Namespace. Update your application to remove
calls to this API.
# Arguments
- `tags`: The tag key-value pairs.
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function tag_attendee(
Tags, attendeeId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags?operation=add",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_attendee(
Tags,
attendeeId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags?operation=add",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_meeting(tags, meeting_id)
tag_meeting(tags, meeting_id, params::Dict{String,<:Any})
Applies the specified tags to the specified Amazon Chime SDK meeting. This API is is no
longer supported and will not be updated. We recommend using the latest version,
TagResource, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `tags`: The tag key-value pairs.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function tag_meeting(Tags, meetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/meetings/$(meetingId)/tags?operation=add",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_meeting(
Tags,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/tags?operation=add",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Applies the specified tags to the specified Amazon Chime SDK meeting resource. This API
is is no longer supported and will not be updated. We recommend using the latest version,
TagResource, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `resource_arn`: The resource ARN.
- `tags`: The tag key-value pairs.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_attendee(tag_keys, attendee_id, meeting_id)
untag_attendee(tag_keys, attendee_id, meeting_id, params::Dict{String,<:Any})
Untags the specified tags from the specified Amazon Chime SDK attendee. UntagAttendee is
not supported in the Amazon Chime SDK Meetings Namespace. Update your application to remove
calls to this API.
# Arguments
- `tag_keys`: The tag keys.
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function untag_attendee(
TagKeys, attendeeId, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags?operation=delete",
Dict{String,Any}("TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_attendee(
TagKeys,
attendeeId,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/attendees/$(attendeeId)/tags?operation=delete",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("TagKeys" => TagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_meeting(tag_keys, meeting_id)
untag_meeting(tag_keys, meeting_id, params::Dict{String,<:Any})
Untags the specified tags from the specified Amazon Chime SDK meeting. This API is is no
longer supported and will not be updated. We recommend using the latest version,
UntagResource, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `tag_keys`: The tag keys.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function untag_meeting(
TagKeys, meetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/meetings/$(meetingId)/tags?operation=delete",
Dict{String,Any}("TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_meeting(
TagKeys,
meetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/meetings/$(meetingId)/tags?operation=delete",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("TagKeys" => TagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Untags the specified tags from the specified Amazon Chime SDK meeting resource. Applies the
specified tags to the specified Amazon Chime SDK meeting resource. This API is is no
longer supported and will not be updated. We recommend using the latest version,
UntagResource, in the Amazon Chime SDK. Using the latest version requires migrating to a
dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `resource_arn`: The resource ARN.
- `tag_keys`: The tag keys.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_account(account_id)
update_account(account_id, params::Dict{String,<:Any})
Updates account details for the specified Amazon Chime account. Currently, only account
name and default license updates are supported for this action.
# Arguments
- `account_id`: The Amazon Chime account ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DefaultLicense"`: The default license applied when you add users to an Amazon Chime
account.
- `"Name"`: The new name for the specified Amazon Chime account.
"""
function update_account(accountId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_account(
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_account_settings(account_settings, account_id)
update_account_settings(account_settings, account_id, params::Dict{String,<:Any})
Updates the settings for the specified Amazon Chime account. You can update settings for
remote control of shared screens, or for the dial-out option. For more information about
these settings, see Use the Policies Page in the Amazon Chime Administration Guide.
# Arguments
- `account_settings`: The Amazon Chime account settings to update.
- `account_id`: The Amazon Chime account ID.
"""
function update_account_settings(
AccountSettings, accountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/accounts/$(accountId)/settings",
Dict{String,Any}("AccountSettings" => AccountSettings);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_account_settings(
AccountSettings,
accountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/accounts/$(accountId)/settings",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("AccountSettings" => AccountSettings), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance(name, app_instance_arn)
update_app_instance(name, app_instance_arn, params::Dict{String,<:Any})
Updates AppInstance metadata. This API is is no longer supported and will not be updated.
We recommend using the latest version, UpdateAppInstance, in the Amazon Chime SDK. Using
the latest version requires migrating to a dedicated namespace. For more information, refer
to Migrating from the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name that you want to change.
- `app_instance_arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata that you want to change.
"""
function update_app_instance(
Name, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance(
Name,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instances/$(appInstanceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance_user(name, app_instance_user_arn)
update_app_instance_user(name, app_instance_user_arn, params::Dict{String,<:Any})
Updates the details of an AppInstanceUser. You can update names and metadata. This API is
is no longer supported and will not be updated. We recommend using the latest version,
UpdateAppInstanceUser, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name of the AppInstanceUser.
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata of the AppInstanceUser.
"""
function update_app_instance_user(
Name, appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/app-instance-users/$(appInstanceUserArn)",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance_user(
Name,
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/app-instance-users/$(appInstanceUserArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_bot(account_id, bot_id)
update_bot(account_id, bot_id, params::Dict{String,<:Any})
Updates the status of the specified bot, such as starting or stopping the bot from running
in your Amazon Chime Enterprise account.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `bot_id`: The bot ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: When true, stops the specified bot from running in your account.
"""
function update_bot(accountId, botId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/bots/$(botId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_bot(
accountId,
botId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/bots/$(botId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel(mode, name, channel_arn)
update_channel(mode, name, channel_arn, params::Dict{String,<:Any})
Update a channel's attributes. Restriction: You can't change a channel's privacy. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version, UpdateChannel, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `mode`: The mode of the update request.
- `name`: The name of the channel.
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata for the update request.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function update_channel(
Mode, Name, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/channels/$(channelArn)",
Dict{String,Any}("Mode" => Mode, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel(
Mode,
Name,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/channels/$(channelArn)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Mode" => Mode, "Name" => Name), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel_message(channel_arn, message_id)
update_channel_message(channel_arn, message_id, params::Dict{String,<:Any})
Updates the content of a message. The x-amz-chime-bearer request header is mandatory. Use
the AppInstanceUserArn of the user that makes the API call as the value in the header.
This API is is no longer supported and will not be updated. We recommend using the latest
version, UpdateChannelMessage, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID string of the message being updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Content"`: The content of the message being updated.
- `"Metadata"`: The metadata of the message being updated.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function update_channel_message(
channelArn, messageId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/channels/$(channelArn)/messages/$(messageId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel_message(
channelArn,
messageId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/channels/$(channelArn)/messages/$(messageId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel_read_marker(channel_arn)
update_channel_read_marker(channel_arn, params::Dict{String,<:Any})
The details of the time when a user last read messages in a channel. The
x-amz-chime-bearer request header is mandatory. Use the AppInstanceUserArn of the user that
makes the API call as the value in the header. This API is is no longer supported and
will not be updated. We recommend using the latest version, UpdateChannelReadMarker, in the
Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace. For
more information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime
SDK Developer Guide.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user that makes the API call.
"""
function update_channel_read_marker(
channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/channels/$(channelArn)/readMarker";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel_read_marker(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/channels/$(channelArn)/readMarker",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_global_settings()
update_global_settings(params::Dict{String,<:Any})
Updates global settings for the administrator's AWS account, such as Amazon Chime Business
Calling and Amazon Chime Voice Connector settings.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BusinessCalling"`: The Amazon Chime Business Calling settings.
- `"VoiceConnector"`: The Amazon Chime Voice Connector settings.
"""
function update_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime("PUT", "/settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function update_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT", "/settings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_phone_number(phone_number_id)
update_phone_number(phone_number_id, params::Dict{String,<:Any})
Updates phone number details, such as product type or calling name, for the specified phone
number ID. You can update one phone number detail at a time. For example, you can update
either the product type or the calling name in one action. For toll-free numbers, you
cannot use the Amazon Chime Business Calling product type. For numbers outside the U.S.,
you must use the Amazon Chime SIP Media Application Dial-In product type. Updates to
outbound calling names can take 72 hours to complete. Pending updates to outbound calling
names must be complete before you can request another update.
# Arguments
- `phone_number_id`: The phone number ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallingName"`: The outbound calling name associated with the phone number.
- `"ProductType"`: The product type.
"""
function update_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_phone_number_settings(calling_name)
update_phone_number_settings(calling_name, params::Dict{String,<:Any})
Updates the phone number settings for the administrator's AWS account, such as the default
outbound calling name. You can update the default outbound calling name once every seven
days. Outbound calling names can take up to 72 hours to update.
# Arguments
- `calling_name`: The default outbound calling name for the account.
"""
function update_phone_number_settings(
CallingName; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/settings/phone-number",
Dict{String,Any}("CallingName" => CallingName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_phone_number_settings(
CallingName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/settings/phone-number",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CallingName" => CallingName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_proxy_session(capabilities, proxy_session_id, voice_connector_id)
update_proxy_session(capabilities, proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Updates the specified proxy session details, such as voice or SMS capabilities. This API
is is no longer supported and will not be updated. We recommend using the latest version,
UpdateProxySession, in the Amazon Chime SDK. Using the latest version requires migrating to
a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `capabilities`: The proxy session capabilities.
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Amazon Chime voice connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpiryMinutes"`: The number of minutes allowed for the proxy session.
"""
function update_proxy_session(
Capabilities,
proxySessionId,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
Dict{String,Any}("Capabilities" => Capabilities);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_proxy_session(
Capabilities,
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Capabilities" => Capabilities), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_room(account_id, room_id)
update_room(account_id, room_id, params::Dict{String,<:Any})
Updates room details, such as the room name, for a room in an Amazon Chime Enterprise
account.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `room_id`: The room ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Name"`: The room name.
"""
function update_room(accountId, roomId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_room(
accountId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_room_membership(account_id, member_id, room_id)
update_room_membership(account_id, member_id, room_id, params::Dict{String,<:Any})
Updates room membership details, such as the member role, for a room in an Amazon Chime
Enterprise account. The member role designates whether the member is a chat room
administrator or a general chat room member. The member role can be updated only for user
IDs.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `member_id`: The member ID.
- `room_id`: The room ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Role"`: The role of the member.
"""
function update_room_membership(
accountId, memberId, roomId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships/$(memberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_room_membership(
accountId,
memberId,
roomId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/rooms/$(roomId)/memberships/$(memberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_media_application(sip_media_application_id)
update_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Updates the details of the specified SIP media application. This API is is no longer
supported and will not be updated. We recommend using the latest version,
UpdateSipMediaApplication, in the Amazon Chime SDK. Using the latest version requires
migrating to a dedicated namespace. For more information, refer to Migrating from the
Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Endpoints"`: The new set of endpoints for the specified SIP media application.
- `"Name"`: The new name for the specified SIP media application.
"""
function update_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_media_application_call(arguments, sip_media_application_id, transaction_id)
update_sip_media_application_call(arguments, sip_media_application_id, transaction_id, params::Dict{String,<:Any})
Invokes the AWS Lambda function associated with the SIP media application and transaction
ID in an update request. The Lambda function can then return a new set of actions. This
API is is no longer supported and will not be updated. We recommend using the latest
version, UpdateSipMediaApplicationCall, in the Amazon Chime SDK. Using the latest version
requires migrating to a dedicated namespace. For more information, refer to Migrating from
the Amazon Chime namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `arguments`: Arguments made available to the Lambda function as part of the
CALL_UPDATE_REQUESTED event. Can contain 0-20 key-value pairs.
- `sip_media_application_id`: The ID of the SIP media application handling the call.
- `transaction_id`: The ID of the call transaction.
"""
function update_sip_media_application_call(
Arguments,
sipMediaApplicationId,
transactionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls/$(transactionId)",
Dict{String,Any}("Arguments" => Arguments);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_media_application_call(
Arguments,
sipMediaApplicationId,
transactionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls/$(transactionId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Arguments" => Arguments), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_rule(name, sip_rule_id)
update_sip_rule(name, sip_rule_id, params::Dict{String,<:Any})
Updates the details of the specified SIP rule. This API is is no longer supported and
will not be updated. We recommend using the latest version, UpdateSipRule, in the Amazon
Chime SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `name`: The new name for the specified SIP rule.
- `sip_rule_id`: The SIP rule ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: The new value specified to indicate whether the rule is disabled.
- `"TargetApplications"`: The new value of the list of target applications.
"""
function update_sip_rule(Name, sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"PUT",
"/sip-rules/$(sipRuleId)",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_rule(
Name,
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/sip-rules/$(sipRuleId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_user(account_id, user_id)
update_user(account_id, user_id, params::Dict{String,<:Any})
Updates user details for a specified user ID. Currently, only LicenseType updates are
supported for this action.
# Arguments
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AlexaForBusinessMetadata"`: The Alexa for Business metadata.
- `"LicenseType"`: The user license type to update. This must be a supported license type
for the Amazon Chime account that the user belongs to.
- `"UserType"`: The user type.
"""
function update_user(accountId, userId; aws_config::AbstractAWSConfig=global_aws_config())
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_user(
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/accounts/$(accountId)/users/$(userId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_user_settings(user_settings, account_id, user_id)
update_user_settings(user_settings, account_id, user_id, params::Dict{String,<:Any})
Updates the settings for the specified user, such as phone number settings.
# Arguments
- `user_settings`: The user settings to update.
- `account_id`: The Amazon Chime account ID.
- `user_id`: The user ID.
"""
function update_user_settings(
UserSettings, accountId, userId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime(
"PUT",
"/accounts/$(accountId)/users/$(userId)/settings",
Dict{String,Any}("UserSettings" => UserSettings);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_user_settings(
UserSettings,
accountId,
userId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/accounts/$(accountId)/users/$(userId)/settings",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("UserSettings" => UserSettings), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_connector(name, require_encryption, voice_connector_id)
update_voice_connector(name, require_encryption, voice_connector_id, params::Dict{String,<:Any})
Updates details for the specified Amazon Chime Voice Connector. This API is is no longer
supported and will not be updated. We recommend using the latest version,
UpdateVoiceConnector, in the Amazon Chime SDK. Using the latest version requires migrating
to a dedicated namespace. For more information, refer to Migrating from the Amazon Chime
namespace in the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name of the Amazon Chime Voice Connector.
- `require_encryption`: When enabled, requires encryption for the Amazon Chime Voice
Connector.
- `voice_connector_id`: The Amazon Chime Voice Connector ID.
"""
function update_voice_connector(
Name,
RequireEncryption,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)",
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_connector(
Name,
RequireEncryption,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connectors/$(voiceConnectorId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_connector_group(name, voice_connector_items, voice_connector_group_id)
update_voice_connector_group(name, voice_connector_items, voice_connector_group_id, params::Dict{String,<:Any})
Updates details of the specified Amazon Chime Voice Connector group, such as the name and
Amazon Chime Voice Connector priority ranking. This API is is no longer supported and
will not be updated. We recommend using the latest version, UpdateVoiceConnectorGroup, in
the Amazon Chime SDK. Using the latest version requires migrating to a dedicated namespace.
For more information, refer to Migrating from the Amazon Chime namespace in the Amazon
Chime SDK Developer Guide.
# Arguments
- `name`: The name of the Amazon Chime Voice Connector group.
- `voice_connector_items`: The VoiceConnectorItems to associate with the group.
- `voice_connector_group_id`: The Amazon Chime Voice Connector group ID.
"""
function update_voice_connector_group(
Name,
VoiceConnectorItems,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connector-groups/$(voiceConnectorGroupId)",
Dict{String,Any}("Name" => Name, "VoiceConnectorItems" => VoiceConnectorItems);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_connector_group(
Name,
VoiceConnectorItems,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"PUT",
"/voice-connector-groups/$(voiceConnectorGroupId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name, "VoiceConnectorItems" => VoiceConnectorItems
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
validate_e911_address(aws_account_id, city, country, postal_code, state, street_info, street_number)
validate_e911_address(aws_account_id, city, country, postal_code, state, street_info, street_number, params::Dict{String,<:Any})
Validates an address to be used for 911 calls made with Amazon Chime Voice Connectors. You
can use validated addresses in a Presence Information Data Format Location Object file that
you include in SIP requests. That helps ensure that addresses are routed to the appropriate
Public Safety Answering Point. This API is is no longer supported and will not be
updated. We recommend using the latest version, ValidateE911Address, in the Amazon Chime
SDK. Using the latest version requires migrating to a dedicated namespace. For more
information, refer to Migrating from the Amazon Chime namespace in the Amazon Chime SDK
Developer Guide.
# Arguments
- `aws_account_id`: The AWS account ID.
- `city`: The address city, such as Portland.
- `country`: The address country, such as US.
- `postal_code`: The address postal code, such as 04352.
- `state`: The address state, such as ME.
- `street_info`: The address street information, such as 8th Avenue.
- `street_number`: The address street number, such as 200 or 2121.
"""
function validate_e911_address(
AwsAccountId,
City,
Country,
PostalCode,
State,
StreetInfo,
StreetNumber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/emergency-calling/address",
Dict{String,Any}(
"AwsAccountId" => AwsAccountId,
"City" => City,
"Country" => Country,
"PostalCode" => PostalCode,
"State" => State,
"StreetInfo" => StreetInfo,
"StreetNumber" => StreetNumber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function validate_e911_address(
AwsAccountId,
City,
Country,
PostalCode,
State,
StreetInfo,
StreetNumber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime(
"POST",
"/emergency-calling/address",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AwsAccountId" => AwsAccountId,
"City" => City,
"Country" => Country,
"PostalCode" => PostalCode,
"State" => State,
"StreetInfo" => StreetInfo,
"StreetNumber" => StreetNumber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 39183 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime_sdk_identity
using AWS.Compat
using AWS.UUIDs
"""
create_app_instance(client_request_token, name)
create_app_instance(client_request_token, name, params::Dict{String,<:Any})
Creates an Amazon Chime SDK messaging AppInstance under an AWS account. Only SDK messaging
customers use this API. CreateAppInstance supports idempotency behavior as described in the
AWS API Standard. identity
# Arguments
- `client_request_token`: The unique ID of the request. Use different tokens to create
different AppInstances.
- `name`: The name of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata of the AppInstance. Limited to a 1KB string in UTF-8.
- `"Tags"`: Tags assigned to the AppInstance.
"""
function create_app_instance(
ClientRequestToken, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"POST",
"/app-instances",
Dict{String,Any}("ClientRequestToken" => ClientRequestToken, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance(
ClientRequestToken,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken, "Name" => Name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance_admin(app_instance_admin_arn, app_instance_arn)
create_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Promotes an AppInstanceUser or AppInstanceBot to an AppInstanceAdmin. The promoted entity
can perform the following actions. ChannelModerator actions across all channels in the
AppInstance. DeleteChannelMessage actions. Only an AppInstanceUser and AppInstanceBot
can be promoted to an AppInstanceAdmin role.
# Arguments
- `app_instance_admin_arn`: The ARN of the administrator of the current AppInstance.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function create_app_instance_admin(
AppInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"POST",
"/app-instances/$(appInstanceArn)/admins",
Dict{String,Any}("AppInstanceAdminArn" => AppInstanceAdminArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance_admin(
AppInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instances/$(appInstanceArn)/admins",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AppInstanceAdminArn" => AppInstanceAdminArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance_bot(app_instance_arn, client_request_token, configuration)
create_app_instance_bot(app_instance_arn, client_request_token, configuration, params::Dict{String,<:Any})
Creates a bot under an Amazon Chime AppInstance. The request consists of a unique
Configuration and Name for that bot.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance request.
- `client_request_token`: The unique ID for the client making the request. Use different
tokens for different AppInstanceBots.
- `configuration`: Configuration information about the Amazon Lex V2 V2 bot.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The request metadata. Limited to a 1KB string in UTF-8.
- `"Name"`: The user's name.
- `"Tags"`: The tags assigned to the AppInstanceBot.
"""
function create_app_instance_bot(
AppInstanceArn,
ClientRequestToken,
Configuration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-bots",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Configuration" => Configuration,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance_bot(
AppInstanceArn,
ClientRequestToken,
Configuration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-bots",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Configuration" => Configuration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_app_instance_user(app_instance_arn, app_instance_user_id, client_request_token, name)
create_app_instance_user(app_instance_arn, app_instance_user_id, client_request_token, name, params::Dict{String,<:Any})
Creates a user under an Amazon Chime AppInstance. The request consists of a unique
appInstanceUserId and Name for that user.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance request.
- `app_instance_user_id`: The user ID of the AppInstance.
- `client_request_token`: The unique ID of the request. Use different tokens to request
additional AppInstances.
- `name`: The user's name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpirationSettings"`: Settings that control the interval after which the
AppInstanceUser is automatically deleted.
- `"Metadata"`: The request's metadata. Limited to a 1KB string in UTF-8.
- `"Tags"`: Tags assigned to the AppInstanceUser.
"""
function create_app_instance_user(
AppInstanceArn,
AppInstanceUserId,
ClientRequestToken,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-users",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"AppInstanceUserId" => AppInstanceUserId,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_app_instance_user(
AppInstanceArn,
AppInstanceUserId,
ClientRequestToken,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-users",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"AppInstanceUserId" => AppInstanceUserId,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance(app_instance_arn)
delete_app_instance(app_instance_arn, params::Dict{String,<:Any})
Deletes an AppInstance and all associated data asynchronously.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function delete_app_instance(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"DELETE",
"/app-instances/$(appInstanceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"DELETE",
"/app-instances/$(appInstanceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_admin(app_instance_admin_arn, app_instance_arn)
delete_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Demotes an AppInstanceAdmin to an AppInstanceUser or AppInstanceBot. This action does not
delete the user.
# Arguments
- `app_instance_admin_arn`: The ARN of the AppInstance's administrator.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function delete_app_instance_admin(
appInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"DELETE",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_admin(
appInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"DELETE",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_bot(app_instance_bot_arn)
delete_app_instance_bot(app_instance_bot_arn, params::Dict{String,<:Any})
Deletes an AppInstanceBot.
# Arguments
- `app_instance_bot_arn`: The ARN of the AppInstanceBot being deleted.
"""
function delete_app_instance_bot(
appInstanceBotArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"DELETE",
"/app-instance-bots/$(appInstanceBotArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_bot(
appInstanceBotArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"DELETE",
"/app-instance-bots/$(appInstanceBotArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_app_instance_user(app_instance_user_arn)
delete_app_instance_user(app_instance_user_arn, params::Dict{String,<:Any})
Deletes an AppInstanceUser.
# Arguments
- `app_instance_user_arn`: The ARN of the user request being deleted.
"""
function delete_app_instance_user(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_app_instance_user(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_app_instance_user_endpoint(app_instance_user_arn, endpoint_id)
deregister_app_instance_user_endpoint(app_instance_user_arn, endpoint_id, params::Dict{String,<:Any})
Deregisters an AppInstanceUserEndpoint.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
- `endpoint_id`: The unique identifier of the AppInstanceUserEndpoint.
"""
function deregister_app_instance_user_endpoint(
appInstanceUserArn, endpointId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_app_instance_user_endpoint(
appInstanceUserArn,
endpointId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"DELETE",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance(app_instance_arn)
describe_app_instance(app_instance_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstance.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function describe_app_instance(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_admin(app_instance_admin_arn, app_instance_arn)
describe_app_instance_admin(app_instance_admin_arn, app_instance_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstanceAdmin.
# Arguments
- `app_instance_admin_arn`: The ARN of the AppInstanceAdmin.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function describe_app_instance_admin(
appInstanceAdminArn, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_admin(
appInstanceAdminArn,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/admins/$(appInstanceAdminArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_bot(app_instance_bot_arn)
describe_app_instance_bot(app_instance_bot_arn, params::Dict{String,<:Any})
The AppInstanceBot's information.
# Arguments
- `app_instance_bot_arn`: The ARN of the AppInstanceBot.
"""
function describe_app_instance_bot(
appInstanceBotArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-bots/$(appInstanceBotArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_bot(
appInstanceBotArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-bots/$(appInstanceBotArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_user(app_instance_user_arn)
describe_app_instance_user(app_instance_user_arn, params::Dict{String,<:Any})
Returns the full details of an AppInstanceUser.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
"""
function describe_app_instance_user(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_user(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_app_instance_user_endpoint(app_instance_user_arn, endpoint_id)
describe_app_instance_user_endpoint(app_instance_user_arn, endpoint_id, params::Dict{String,<:Any})
Returns the full details of an AppInstanceUserEndpoint.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
- `endpoint_id`: The unique identifier of the AppInstanceUserEndpoint.
"""
function describe_app_instance_user_endpoint(
appInstanceUserArn, endpointId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_app_instance_user_endpoint(
appInstanceUserArn,
endpointId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_app_instance_retention_settings(app_instance_arn)
get_app_instance_retention_settings(app_instance_arn, params::Dict{String,<:Any})
Gets the retention settings for an AppInstance.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
"""
function get_app_instance_retention_settings(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/retention-settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_app_instance_retention_settings(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/retention-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instance_admins(app_instance_arn)
list_app_instance_admins(app_instance_arn, params::Dict{String,<:Any})
Returns a list of the administrators in the AppInstance.
# Arguments
- `app_instance_arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of administrators that you want to return.
- `"next-token"`: The token returned from previous API requests until the number of
administrators is reached.
"""
function list_app_instance_admins(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/admins";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_admins(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instances/$(appInstanceArn)/admins",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instance_bots(app-instance-arn)
list_app_instance_bots(app-instance-arn, params::Dict{String,<:Any})
Lists all AppInstanceBots created under a single AppInstance.
# Arguments
- `app-instance-arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of requests to return.
- `"next-token"`: The token passed by previous API calls until all requested bots are
returned.
"""
function list_app_instance_bots(
app_instance_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-bots",
Dict{String,Any}("app-instance-arn" => app_instance_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_bots(
app_instance_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-bots",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("app-instance-arn" => app_instance_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instance_user_endpoints(app_instance_user_arn)
list_app_instance_user_endpoints(app_instance_user_arn, params::Dict{String,<:Any})
Lists all the AppInstanceUserEndpoints created under a single AppInstanceUser.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of endpoints that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested endpoints are
returned.
"""
function list_app_instance_user_endpoints(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)/endpoints";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_user_endpoints(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-users/$(appInstanceUserArn)/endpoints",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instance_users(app-instance-arn)
list_app_instance_users(app-instance-arn, params::Dict{String,<:Any})
List all AppInstanceUsers created under a single AppInstance.
# Arguments
- `app-instance-arn`: The ARN of the AppInstance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of requests that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested users are
returned.
"""
function list_app_instance_users(
app_instance_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instance-users",
Dict{String,Any}("app-instance-arn" => app_instance_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_app_instance_users(
app_instance_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"GET",
"/app-instance-users",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("app-instance-arn" => app_instance_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_app_instances()
list_app_instances(params::Dict{String,<:Any})
Lists all Amazon Chime AppInstances created under a single AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of AppInstances that you want to return.
- `"next-token"`: The token passed by previous API requests until you reach the maximum
number of AppInstances.
"""
function list_app_instances(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_identity(
"GET", "/app-instances"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_app_instances(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/app-instances",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Lists the tags applied to an Amazon Chime SDK identity resource.
# Arguments
- `arn`: The ARN of the resource.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_identity(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_app_instance_retention_settings(app_instance_retention_settings, app_instance_arn)
put_app_instance_retention_settings(app_instance_retention_settings, app_instance_arn, params::Dict{String,<:Any})
Sets the amount of time in days that a given AppInstance retains data.
# Arguments
- `app_instance_retention_settings`: The time in days to retain data. Data type: number.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function put_app_instance_retention_settings(
AppInstanceRetentionSettings,
appInstanceArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instances/$(appInstanceArn)/retention-settings",
Dict{String,Any}("AppInstanceRetentionSettings" => AppInstanceRetentionSettings);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_app_instance_retention_settings(
AppInstanceRetentionSettings,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instances/$(appInstanceArn)/retention-settings",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceRetentionSettings" => AppInstanceRetentionSettings
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_app_instance_user_expiration_settings(app_instance_user_arn)
put_app_instance_user_expiration_settings(app_instance_user_arn, params::Dict{String,<:Any})
Sets the number of days before the AppInstanceUser is automatically deleted. A background
process deletes expired AppInstanceUsers within 6 hours of expiration. Actual deletion
times may vary. Expired AppInstanceUsers that have not yet been deleted appear as active,
and you can update their expiration settings. The system honors the new settings.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpirationSettings"`: Settings that control the interval after which an AppInstanceUser
is automatically deleted.
"""
function put_app_instance_user_expiration_settings(
appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)/expiration-settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_app_instance_user_expiration_settings(
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)/expiration-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_app_instance_user_endpoint(client_request_token, endpoint_attributes, resource_arn, type, app_instance_user_arn)
register_app_instance_user_endpoint(client_request_token, endpoint_attributes, resource_arn, type, app_instance_user_arn, params::Dict{String,<:Any})
Registers an endpoint under an Amazon Chime AppInstanceUser. The endpoint receives messages
for a user. For push notifications, the endpoint is a mobile device used to receive mobile
push notifications for a user.
# Arguments
- `client_request_token`: The unique ID assigned to the request. Use different tokens to
register other endpoints.
- `endpoint_attributes`: The attributes of an Endpoint.
- `resource_arn`: The ARN of the resource to which the endpoint belongs.
- `type`: The type of the AppInstanceUserEndpoint. Supported types: APNS: The mobile
notification service for an Apple device. APNS_SANDBOX: The sandbox environment of the
mobile notification service for an Apple device. GCM: The mobile notification service
for an Android device. Populate the ResourceArn value of each type as PinpointAppArn.
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AllowMessages"`: Boolean that controls whether the AppInstanceUserEndpoint is opted in
to receive messages. ALL indicates the endpoint receives all messages. NONE indicates the
endpoint receives no messages.
- `"Name"`: The name of the AppInstanceUserEndpoint.
"""
function register_app_instance_user_endpoint(
ClientRequestToken,
EndpointAttributes,
ResourceArn,
Type,
appInstanceUserArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-users/$(appInstanceUserArn)/endpoints",
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"EndpointAttributes" => EndpointAttributes,
"ResourceArn" => ResourceArn,
"Type" => Type,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_app_instance_user_endpoint(
ClientRequestToken,
EndpointAttributes,
ResourceArn,
Type,
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/app-instance-users/$(appInstanceUserArn)/endpoints",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"EndpointAttributes" => EndpointAttributes,
"ResourceArn" => ResourceArn,
"Type" => Type,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Applies the specified tags to the specified Amazon Chime SDK identity resource.
# Arguments
- `resource_arn`: The resource ARN.
- `tags`: The tag key-value pairs.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_identity(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the specified tags from the specified Amazon Chime SDK identity resource.
# Arguments
- `resource_arn`: The resource ARN.
- `tag_keys`: The tag keys.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance(metadata, name, app_instance_arn)
update_app_instance(metadata, name, app_instance_arn, params::Dict{String,<:Any})
Updates AppInstance metadata.
# Arguments
- `metadata`: The metadata that you want to change.
- `name`: The name that you want to change.
- `app_instance_arn`: The ARN of the AppInstance.
"""
function update_app_instance(
Metadata, Name, appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"PUT",
"/app-instances/$(appInstanceArn)",
Dict{String,Any}("Metadata" => Metadata, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance(
Metadata,
Name,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instances/$(appInstanceArn)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Metadata" => Metadata, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance_bot(metadata, name, app_instance_bot_arn)
update_app_instance_bot(metadata, name, app_instance_bot_arn, params::Dict{String,<:Any})
Updates the name and metadata of an AppInstanceBot.
# Arguments
- `metadata`: The metadata of the AppInstanceBot.
- `name`: The name of the AppInstanceBot.
- `app_instance_bot_arn`: The ARN of the AppInstanceBot.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Configuration"`: The configuration for the bot update.
"""
function update_app_instance_bot(
Metadata, Name, appInstanceBotArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"PUT",
"/app-instance-bots/$(appInstanceBotArn)",
Dict{String,Any}("Metadata" => Metadata, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance_bot(
Metadata,
Name,
appInstanceBotArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instance-bots/$(appInstanceBotArn)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Metadata" => Metadata, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance_user(metadata, name, app_instance_user_arn)
update_app_instance_user(metadata, name, app_instance_user_arn, params::Dict{String,<:Any})
Updates the details of an AppInstanceUser. You can update names and metadata.
# Arguments
- `metadata`: The metadata of the AppInstanceUser.
- `name`: The name of the AppInstanceUser.
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
"""
function update_app_instance_user(
Metadata, Name, appInstanceUserArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)",
Dict{String,Any}("Metadata" => Metadata, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance_user(
Metadata,
Name,
appInstanceUserArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Metadata" => Metadata, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_app_instance_user_endpoint(app_instance_user_arn, endpoint_id)
update_app_instance_user_endpoint(app_instance_user_arn, endpoint_id, params::Dict{String,<:Any})
Updates the details of an AppInstanceUserEndpoint. You can update the name and AllowMessage
values.
# Arguments
- `app_instance_user_arn`: The ARN of the AppInstanceUser.
- `endpoint_id`: The unique identifier of the AppInstanceUserEndpoint.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AllowMessages"`: Boolean that controls whether the AppInstanceUserEndpoint is opted in
to receive messages. ALL indicates the endpoint will receive all messages. NONE indicates
the endpoint will receive no messages.
- `"Name"`: The name of the AppInstanceUserEndpoint.
"""
function update_app_instance_user_endpoint(
appInstanceUserArn, endpointId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_app_instance_user_endpoint(
appInstanceUserArn,
endpointId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_identity(
"PUT",
"/app-instance-users/$(appInstanceUserArn)/endpoints/$(endpointId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 44233 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime_sdk_media_pipelines
using AWS.Compat
using AWS.UUIDs
"""
create_media_capture_pipeline(sink_arn, sink_type, source_arn, source_type)
create_media_capture_pipeline(sink_arn, sink_type, source_arn, source_type, params::Dict{String,<:Any})
Creates a media pipeline.
# Arguments
- `sink_arn`: The ARN of the sink type.
- `sink_type`: Destination type to which the media artifacts are saved. You must use an S3
bucket.
- `source_arn`: ARN of the source from which the media artifacts are captured.
- `source_type`: Source type from which the media artifacts are captured. A Chime SDK
Meeting is the only supported source.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChimeSdkMeetingConfiguration"`: The configuration for a specified media pipeline.
SourceType must be ChimeSdkMeeting.
- `"ClientRequestToken"`: The unique identifier for the client request. The token makes the
API request idempotent. Use a unique token for each media pipeline request.
- `"Tags"`: The tag key-value pairs.
"""
function create_media_capture_pipeline(
SinkArn,
SinkType,
SourceArn,
SourceType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-capture-pipelines",
Dict{String,Any}(
"SinkArn" => SinkArn,
"SinkType" => SinkType,
"SourceArn" => SourceArn,
"SourceType" => SourceType,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_capture_pipeline(
SinkArn,
SinkType,
SourceArn,
SourceType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-capture-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"SinkArn" => SinkArn,
"SinkType" => SinkType,
"SourceArn" => SourceArn,
"SourceType" => SourceType,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_concatenation_pipeline(sinks, sources)
create_media_concatenation_pipeline(sinks, sources, params::Dict{String,<:Any})
Creates a media concatenation pipeline.
# Arguments
- `sinks`: An object that specifies the data sinks for the media concatenation pipeline.
- `sources`: An object that specifies the sources for the media concatenation pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the client request. The token makes the
API request idempotent. Use a unique token for each media concatenation pipeline request.
- `"Tags"`: The tags associated with the media concatenation pipeline.
"""
function create_media_concatenation_pipeline(
Sinks, Sources; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-concatenation-pipelines",
Dict{String,Any}(
"Sinks" => Sinks, "Sources" => Sources, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_concatenation_pipeline(
Sinks,
Sources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-concatenation-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Sinks" => Sinks,
"Sources" => Sources,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_insights_pipeline(media_insights_pipeline_configuration_arn)
create_media_insights_pipeline(media_insights_pipeline_configuration_arn, params::Dict{String,<:Any})
Creates a media insights pipeline.
# Arguments
- `media_insights_pipeline_configuration_arn`: The ARN of the pipeline's configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the media insights pipeline request.
- `"KinesisVideoStreamRecordingSourceRuntimeConfiguration"`: The runtime configuration for
the Kinesis video recording stream source.
- `"KinesisVideoStreamSourceRuntimeConfiguration"`: The runtime configuration for the
Kinesis video stream source of the media insights pipeline.
- `"MediaInsightsRuntimeMetadata"`: The runtime metadata for the media insights pipeline.
Consists of a key-value map of strings.
- `"S3RecordingSinkRuntimeConfiguration"`: The runtime configuration for the S3 recording
sink. If specified, the settings in this structure override any settings in
S3RecordingSinkConfiguration.
- `"Tags"`: The tags assigned to the media insights pipeline.
"""
function create_media_insights_pipeline(
MediaInsightsPipelineConfigurationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines",
Dict{String,Any}(
"MediaInsightsPipelineConfigurationArn" =>
MediaInsightsPipelineConfigurationArn,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_insights_pipeline(
MediaInsightsPipelineConfigurationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"MediaInsightsPipelineConfigurationArn" =>
MediaInsightsPipelineConfigurationArn,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_insights_pipeline_configuration(elements, media_insights_pipeline_configuration_name, resource_access_role_arn)
create_media_insights_pipeline_configuration(elements, media_insights_pipeline_configuration_name, resource_access_role_arn, params::Dict{String,<:Any})
A structure that contains the static configurations for a media insights pipeline.
# Arguments
- `elements`: The elements in the request, such as a processor for Amazon Transcribe or a
sink for a Kinesis Data Stream.
- `media_insights_pipeline_configuration_name`: The name of the media insights pipeline
configuration.
- `resource_access_role_arn`: The ARN of the role used by the service to access Amazon Web
Services resources, including Transcribe and Transcribe Call Analytics, on the caller’s
behalf.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the media insights pipeline
configuration request.
- `"RealTimeAlertConfiguration"`: The configuration settings for the real-time alerts in a
media insights pipeline configuration.
- `"Tags"`: The tags assigned to the media insights pipeline configuration.
"""
function create_media_insights_pipeline_configuration(
Elements,
MediaInsightsPipelineConfigurationName,
ResourceAccessRoleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipeline-configurations",
Dict{String,Any}(
"Elements" => Elements,
"MediaInsightsPipelineConfigurationName" =>
MediaInsightsPipelineConfigurationName,
"ResourceAccessRoleArn" => ResourceAccessRoleArn,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_insights_pipeline_configuration(
Elements,
MediaInsightsPipelineConfigurationName,
ResourceAccessRoleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipeline-configurations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Elements" => Elements,
"MediaInsightsPipelineConfigurationName" =>
MediaInsightsPipelineConfigurationName,
"ResourceAccessRoleArn" => ResourceAccessRoleArn,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_live_connector_pipeline(sinks, sources)
create_media_live_connector_pipeline(sinks, sources, params::Dict{String,<:Any})
Creates a media live connector pipeline in an Amazon Chime SDK meeting.
# Arguments
- `sinks`: The media live connector pipeline's data sinks.
- `sources`: The media live connector pipeline's data sources.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The token assigned to the client making the request.
- `"Tags"`: The tags associated with the media live connector pipeline.
"""
function create_media_live_connector_pipeline(
Sinks, Sources; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-live-connector-pipelines",
Dict{String,Any}(
"Sinks" => Sinks, "Sources" => Sources, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_live_connector_pipeline(
Sinks,
Sources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-live-connector-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Sinks" => Sinks,
"Sources" => Sources,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_pipeline_kinesis_video_stream_pool(pool_name, stream_configuration)
create_media_pipeline_kinesis_video_stream_pool(pool_name, stream_configuration, params::Dict{String,<:Any})
Creates an Kinesis video stream pool for the media pipeline.
# Arguments
- `pool_name`: The name of the video stream pool.
- `stream_configuration`: The configuration settings for the video stream.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The token assigned to the client making the request.
- `"Tags"`: The tags assigned to the video stream pool.
"""
function create_media_pipeline_kinesis_video_stream_pool(
PoolName, StreamConfiguration; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-pipeline-kinesis-video-stream-pools",
Dict{String,Any}(
"PoolName" => PoolName,
"StreamConfiguration" => StreamConfiguration,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_pipeline_kinesis_video_stream_pool(
PoolName,
StreamConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-pipeline-kinesis-video-stream-pools",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PoolName" => PoolName,
"StreamConfiguration" => StreamConfiguration,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_media_stream_pipeline(sinks, sources)
create_media_stream_pipeline(sinks, sources, params::Dict{String,<:Any})
Creates a streaming media pipeline.
# Arguments
- `sinks`: The data sink for the media pipeline.
- `sources`: The data sources for the media pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The token assigned to the client making the request.
- `"Tags"`: The tags assigned to the media pipeline.
"""
function create_media_stream_pipeline(
Sinks, Sources; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-stream-pipelines",
Dict{String,Any}(
"Sinks" => Sinks, "Sources" => Sources, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_media_stream_pipeline(
Sinks,
Sources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/sdk-media-stream-pipelines",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Sinks" => Sinks,
"Sources" => Sources,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_media_capture_pipeline(media_pipeline_id)
delete_media_capture_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Deletes the media pipeline.
# Arguments
- `media_pipeline_id`: The ID of the media pipeline being deleted.
"""
function delete_media_capture_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"DELETE",
"/sdk-media-capture-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_media_capture_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"DELETE",
"/sdk-media-capture-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_media_insights_pipeline_configuration(identifier)
delete_media_insights_pipeline_configuration(identifier, params::Dict{String,<:Any})
Deletes the specified configuration settings.
# Arguments
- `identifier`: The unique identifier of the resource to be deleted. Valid values include
the name and ARN of the media insights pipeline configuration.
"""
function delete_media_insights_pipeline_configuration(
identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"DELETE",
"/media-insights-pipeline-configurations/$(identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_media_insights_pipeline_configuration(
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"DELETE",
"/media-insights-pipeline-configurations/$(identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_media_pipeline(media_pipeline_id)
delete_media_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Deletes the media pipeline.
# Arguments
- `media_pipeline_id`: The ID of the media pipeline to delete.
"""
function delete_media_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"DELETE",
"/sdk-media-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_media_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"DELETE",
"/sdk-media-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_media_pipeline_kinesis_video_stream_pool(identifier)
delete_media_pipeline_kinesis_video_stream_pool(identifier, params::Dict{String,<:Any})
Deletes an Kinesis video stream pool.
# Arguments
- `identifier`: The ID of the pool being deleted.
"""
function delete_media_pipeline_kinesis_video_stream_pool(
identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"DELETE",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_media_pipeline_kinesis_video_stream_pool(
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"DELETE",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_media_capture_pipeline(media_pipeline_id)
get_media_capture_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Gets an existing media pipeline.
# Arguments
- `media_pipeline_id`: The ID of the pipeline that you want to get.
"""
function get_media_capture_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-capture-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_media_capture_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-capture-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_media_insights_pipeline_configuration(identifier)
get_media_insights_pipeline_configuration(identifier, params::Dict{String,<:Any})
Gets the configuration settings for a media insights pipeline.
# Arguments
- `identifier`: The unique identifier of the requested resource. Valid values include the
name and ARN of the media insights pipeline configuration.
"""
function get_media_insights_pipeline_configuration(
identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipeline-configurations/$(identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_media_insights_pipeline_configuration(
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipeline-configurations/$(identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_media_pipeline(media_pipeline_id)
get_media_pipeline(media_pipeline_id, params::Dict{String,<:Any})
Gets an existing media pipeline.
# Arguments
- `media_pipeline_id`: The ID of the pipeline that you want to get.
"""
function get_media_pipeline(
mediaPipelineId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-pipelines/$(mediaPipelineId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_media_pipeline(
mediaPipelineId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-pipelines/$(mediaPipelineId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_media_pipeline_kinesis_video_stream_pool(identifier)
get_media_pipeline_kinesis_video_stream_pool(identifier, params::Dict{String,<:Any})
Gets an Kinesis video stream pool.
# Arguments
- `identifier`: The ID of the video stream pool.
"""
function get_media_pipeline_kinesis_video_stream_pool(
identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_media_pipeline_kinesis_video_stream_pool(
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_speaker_search_task(identifier, speaker_search_task_id)
get_speaker_search_task(identifier, speaker_search_task_id, params::Dict{String,<:Any})
Retrieves the details of the specified speaker search task.
# Arguments
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
- `speaker_search_task_id`: The ID of the speaker search task.
"""
function get_speaker_search_task(
identifier, speakerSearchTaskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks/$(speakerSearchTaskId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_speaker_search_task(
identifier,
speakerSearchTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks/$(speakerSearchTaskId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_tone_analysis_task(identifier, voice_tone_analysis_task_id)
get_voice_tone_analysis_task(identifier, voice_tone_analysis_task_id, params::Dict{String,<:Any})
Retrieves the details of a voice tone analysis task.
# Arguments
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
- `voice_tone_analysis_task_id`: The ID of the voice tone analysis task.
"""
function get_voice_tone_analysis_task(
identifier, voiceToneAnalysisTaskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks/$(voiceToneAnalysisTaskId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_tone_analysis_task(
identifier,
voiceToneAnalysisTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks/$(voiceToneAnalysisTaskId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_media_capture_pipelines()
list_media_capture_pipelines(params::Dict{String,<:Any})
Returns a list of media pipelines.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Valid Range: 1
- 99.
- `"next-token"`: The token used to retrieve the next page of results.
"""
function list_media_capture_pipelines(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-capture-pipelines";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_media_capture_pipelines(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-capture-pipelines",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_media_insights_pipeline_configurations()
list_media_insights_pipeline_configurations(params::Dict{String,<:Any})
Lists the available media insights pipeline configurations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
"""
function list_media_insights_pipeline_configurations(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipeline-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_media_insights_pipeline_configurations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-insights-pipeline-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_media_pipeline_kinesis_video_stream_pools()
list_media_pipeline_kinesis_video_stream_pools(params::Dict{String,<:Any})
Lists the video stream pools in the media pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
"""
function list_media_pipeline_kinesis_video_stream_pools(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-pipeline-kinesis-video-stream-pools";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_media_pipeline_kinesis_video_stream_pools(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/media-pipeline-kinesis-video-stream-pools",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_media_pipelines()
list_media_pipelines(params::Dict{String,<:Any})
Returns a list of media pipelines.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Valid Range: 1
- 99.
- `"next-token"`: The token used to retrieve the next page of results.
"""
function list_media_pipelines(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-pipelines";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_media_pipelines(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/sdk-media-pipelines",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Lists the tags available for a media pipeline.
# Arguments
- `arn`: The ARN of the media pipeline associated with any tags. The ARN consists of the
pipeline's region, resource ID, and pipeline ID.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_media_pipelines(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_speaker_search_task(voice_profile_domain_arn, identifier)
start_speaker_search_task(voice_profile_domain_arn, identifier, params::Dict{String,<:Any})
Starts a speaker search task. Before starting any speaker search tasks, you must provide
all notices and obtain all consents from the speaker as required under applicable privacy
and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
# Arguments
- `voice_profile_domain_arn`: The ARN of the voice profile domain that will store the voice
profile.
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the client request. Use a different
token for different speaker search tasks.
- `"KinesisVideoStreamSourceTaskConfiguration"`: The task configuration for the Kinesis
video stream source of the media insights pipeline.
"""
function start_speaker_search_task(
VoiceProfileDomainArn, identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks?operation=start",
Dict{String,Any}(
"VoiceProfileDomainArn" => VoiceProfileDomainArn,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_speaker_search_task(
VoiceProfileDomainArn,
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks?operation=start",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"VoiceProfileDomainArn" => VoiceProfileDomainArn,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_voice_tone_analysis_task(language_code, identifier)
start_voice_tone_analysis_task(language_code, identifier, params::Dict{String,<:Any})
Starts a voice tone analysis task. For more information about voice tone analysis, see
Using Amazon Chime SDK voice analytics in the Amazon Chime SDK Developer Guide. Before
starting any voice tone analysis tasks, you must provide all notices and obtain all
consents from the speaker as required under applicable privacy and biometrics laws, and as
required under the AWS service terms for the Amazon Chime SDK.
# Arguments
- `language_code`: The language code.
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the client request. Use a different
token for different voice tone analysis tasks.
- `"KinesisVideoStreamSourceTaskConfiguration"`: The task configuration for the Kinesis
video stream source of the media insights pipeline.
"""
function start_voice_tone_analysis_task(
LanguageCode, identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks?operation=start",
Dict{String,Any}(
"LanguageCode" => LanguageCode, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_voice_tone_analysis_task(
LanguageCode,
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks?operation=start",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LanguageCode" => LanguageCode, "ClientRequestToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_speaker_search_task(identifier, speaker_search_task_id)
stop_speaker_search_task(identifier, speaker_search_task_id, params::Dict{String,<:Any})
Stops a speaker search task.
# Arguments
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
- `speaker_search_task_id`: The speaker search task ID.
"""
function stop_speaker_search_task(
identifier, speakerSearchTaskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks/$(speakerSearchTaskId)?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_speaker_search_task(
identifier,
speakerSearchTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/speaker-search-tasks/$(speakerSearchTaskId)?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_voice_tone_analysis_task(identifier, voice_tone_analysis_task_id)
stop_voice_tone_analysis_task(identifier, voice_tone_analysis_task_id, params::Dict{String,<:Any})
Stops a voice tone analysis task.
# Arguments
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
- `voice_tone_analysis_task_id`: The ID of the voice tone analysis task.
"""
function stop_voice_tone_analysis_task(
identifier, voiceToneAnalysisTaskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks/$(voiceToneAnalysisTaskId)?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_voice_tone_analysis_task(
identifier,
voiceToneAnalysisTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/media-insights-pipelines/$(identifier)/voice-tone-analysis-tasks/$(voiceToneAnalysisTaskId)?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
The ARN of the media pipeline that you want to tag. Consists of the pipeline's endpoint
region, resource ID, and pipeline ID.
# Arguments
- `resource_arn`: The ARN of the media pipeline associated with any tags. The ARN consists
of the pipeline's endpoint region, resource ID, and pipeline ID.
- `tags`: The tags associated with the specified media pipeline.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_media_pipelines(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes any tags from a media pipeline.
# Arguments
- `resource_arn`: The ARN of the pipeline that you want to untag.
- `tag_keys`: The key/value pairs in the tag that you want to remove.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_media_insights_pipeline_configuration(elements, resource_access_role_arn, identifier)
update_media_insights_pipeline_configuration(elements, resource_access_role_arn, identifier, params::Dict{String,<:Any})
Updates the media insights pipeline's configuration settings.
# Arguments
- `elements`: The elements in the request, such as a processor for Amazon Transcribe or a
sink for a Kinesis Data Stream..
- `resource_access_role_arn`: The ARN of the role used by the service to access Amazon Web
Services resources.
- `identifier`: The unique identifier for the resource to be updated. Valid values include
the name and ARN of the media insights pipeline configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RealTimeAlertConfiguration"`: The configuration settings for real-time alerts for the
media insights pipeline.
"""
function update_media_insights_pipeline_configuration(
Elements,
ResourceAccessRoleArn,
identifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"PUT",
"/media-insights-pipeline-configurations/$(identifier)",
Dict{String,Any}(
"Elements" => Elements, "ResourceAccessRoleArn" => ResourceAccessRoleArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_media_insights_pipeline_configuration(
Elements,
ResourceAccessRoleArn,
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"PUT",
"/media-insights-pipeline-configurations/$(identifier)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Elements" => Elements, "ResourceAccessRoleArn" => ResourceAccessRoleArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_media_insights_pipeline_status(update_status, identifier)
update_media_insights_pipeline_status(update_status, identifier, params::Dict{String,<:Any})
Updates the status of a media insights pipeline.
# Arguments
- `update_status`: The requested status of the media insights pipeline.
- `identifier`: The unique identifier of the resource to be updated. Valid values include
the ID and ARN of the media insights pipeline.
"""
function update_media_insights_pipeline_status(
UpdateStatus, identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"PUT",
"/media-insights-pipeline-status/$(identifier)",
Dict{String,Any}("UpdateStatus" => UpdateStatus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_media_insights_pipeline_status(
UpdateStatus,
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"PUT",
"/media-insights-pipeline-status/$(identifier)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("UpdateStatus" => UpdateStatus), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_media_pipeline_kinesis_video_stream_pool(identifier)
update_media_pipeline_kinesis_video_stream_pool(identifier, params::Dict{String,<:Any})
Updates an Kinesis video stream pool in a media pipeline.
# Arguments
- `identifier`: The ID of the video stream pool.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StreamConfiguration"`: The configuration settings for the video stream.
"""
function update_media_pipeline_kinesis_video_stream_pool(
identifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_media_pipelines(
"PUT",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_media_pipeline_kinesis_video_stream_pool(
identifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_media_pipelines(
"PUT",
"/media-pipeline-kinesis-video-stream-pools/$(identifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 33504 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime_sdk_meetings
using AWS.Compat
using AWS.UUIDs
"""
batch_create_attendee(attendees, meeting_id)
batch_create_attendee(attendees, meeting_id, params::Dict{String,<:Any})
Creates up to 100 attendees for an active Amazon Chime SDK meeting. For more information
about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime Developer
Guide.
# Arguments
- `attendees`: The attendee information, including attendees' IDs and join tokens.
- `meeting_id`: The Amazon Chime SDK ID of the meeting to which you're adding attendees.
"""
function batch_create_attendee(
Attendees, MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/attendees?operation=batch-create",
Dict{String,Any}("Attendees" => Attendees);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_attendee(
Attendees,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/attendees?operation=batch-create",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Attendees" => Attendees), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_update_attendee_capabilities_except(capabilities, excluded_attendee_ids, meeting_id)
batch_update_attendee_capabilities_except(capabilities, excluded_attendee_ids, meeting_id, params::Dict{String,<:Any})
Updates AttendeeCapabilities except the capabilities listed in an ExcludedAttendeeIds
table. You use the capabilities with a set of values that control what the capabilities
can do, such as SendReceive data. For more information about those values, see . When
using capabilities, be aware of these corner cases: If you specify
MeetingFeatures:Video:MaxResolution:None when you create a meeting, all API requests that
include SendReceive, Send, or Receive for AttendeeCapabilities:Video will be rejected with
ValidationError 400. If you specify MeetingFeatures:Content:MaxResolution:None when you
create a meeting, all API requests that include SendReceive, Send, or Receive for
AttendeeCapabilities:Content will be rejected with ValidationError 400. You can't set
content capabilities to SendReceive or Receive unless you also set video capabilities to
SendReceive or Receive. If you don't set the video capability to receive, the response will
contain an HTTP 400 Bad Request status code. However, you can set your video capability to
receive and you set your content capability to not receive. When you change an audio
capability from None or Receive to Send or SendReceive , and if the attendee left their
microphone unmuted, audio will flow from the attendee to the other meeting participants.
When you change a video or content capability from None or Receive to Send or SendReceive ,
and if the attendee turned on their video or content streams, remote attendees can receive
those streams, but only after media renegotiation between the client and the Amazon Chime
back-end server.
# Arguments
- `capabilities`: The capabilities (audio, video, or content) that you want to update.
- `excluded_attendee_ids`: The AttendeeIDs that you want to exclude from one or more
capabilities.
- `meeting_id`: The ID of the meeting associated with the update request.
"""
function batch_update_attendee_capabilities_except(
Capabilities,
ExcludedAttendeeIds,
MeetingId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"PUT",
"/meetings/$(MeetingId)/attendees/capabilities?operation=batch-update-except",
Dict{String,Any}(
"Capabilities" => Capabilities, "ExcludedAttendeeIds" => ExcludedAttendeeIds
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_update_attendee_capabilities_except(
Capabilities,
ExcludedAttendeeIds,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"PUT",
"/meetings/$(MeetingId)/attendees/capabilities?operation=batch-update-except",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Capabilities" => Capabilities,
"ExcludedAttendeeIds" => ExcludedAttendeeIds,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_attendee(external_user_id, meeting_id)
create_attendee(external_user_id, meeting_id, params::Dict{String,<:Any})
Creates a new attendee for an active Amazon Chime SDK meeting. For more information about
the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime Developer Guide.
# Arguments
- `external_user_id`: The Amazon Chime SDK external user ID. An idempotency token. Links
the attendee to an identity managed by a builder application. Pattern:
[-_&@+=,(){}[]/«».:|'\"#a-zA-Z0-9À-ÿs]* Values that begin with aws: are reserved.
You can't configure a value that uses this prefix.
- `meeting_id`: The unique ID of the meeting.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Capabilities"`: The capabilities (audio, video, or content) that you want to grant an
attendee. If you don't specify capabilities, all users have send and receive capabilities
on all media channels by default. You use the capabilities with a set of values that
control what the capabilities can do, such as SendReceive data. For more information about
those values, see . When using capabilities, be aware of these corner cases: If you
specify MeetingFeatures:Video:MaxResolution:None when you create a meeting, all API
requests that include SendReceive, Send, or Receive for AttendeeCapabilities:Video will be
rejected with ValidationError 400. If you specify
MeetingFeatures:Content:MaxResolution:None when you create a meeting, all API requests that
include SendReceive, Send, or Receive for AttendeeCapabilities:Content will be rejected
with ValidationError 400. You can't set content capabilities to SendReceive or Receive
unless you also set video capabilities to SendReceive or Receive. If you don't set the
video capability to receive, the response will contain an HTTP 400 Bad Request status code.
However, you can set your video capability to receive and you set your content capability
to not receive. When you change an audio capability from None or Receive to Send or
SendReceive , and if the attendee left their microphone unmuted, audio will flow from the
attendee to the other meeting participants. When you change a video or content capability
from None or Receive to Send or SendReceive , and if the attendee turned on their video or
content streams, remote attendees can receive those streams, but only after media
renegotiation between the client and the Amazon Chime back-end server.
"""
function create_attendee(
ExternalUserId, MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/attendees",
Dict{String,Any}("ExternalUserId" => ExternalUserId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_attendee(
ExternalUserId,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/attendees",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExternalUserId" => ExternalUserId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_meeting(client_request_token, external_meeting_id, media_region)
create_meeting(client_request_token, external_meeting_id, media_region, params::Dict{String,<:Any})
Creates a new Amazon Chime SDK meeting in the specified media Region with no initial
attendees. For more information about specifying media Regions, see Amazon Chime SDK Media
Regions in the Amazon Chime Developer Guide. For more information about the Amazon Chime
SDK, see Using the Amazon Chime SDK in the Amazon Chime Developer Guide.
# Arguments
- `client_request_token`: The unique identifier for the client request. Use a different
token for different meetings.
- `external_meeting_id`: The external meeting ID. Pattern:
[-_&@+=,(){}[]/«».:|'\"#a-zA-Z0-9À-ÿs]* Values that begin with aws: are reserved.
You can't configure a value that uses this prefix. Case insensitive.
- `media_region`: The Region in which to create the meeting. Available values: af-south-1,
ap-northeast-1, ap-northeast-2, ap-south-1, ap-southeast-1, ap-southeast-2, ca-central-1,
eu-central-1, eu-north-1, eu-south-1, eu-west-1, eu-west-2, eu-west-3, sa-east-1,
us-east-1, us-east-2, us-west-1, us-west-2. Available values in Amazon Web Services
GovCloud (US) Regions: us-gov-east-1, us-gov-west-1.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MeetingFeatures"`: Lists the audio and video features enabled for a meeting, such as
echo reduction.
- `"MeetingHostId"`: Reserved.
- `"NotificationsConfiguration"`: The configuration for resource targets to receive
notifications when meeting and attendee events occur.
- `"PrimaryMeetingId"`: When specified, replicates the media from the primary meeting to
the new meeting.
- `"Tags"`: Applies one or more tags to an Amazon Chime SDK meeting. Note the following:
Not all resources have tags. For a list of services with resources that support tagging
using this operation, see Services that support the Resource Groups Tagging API. If the
resource doesn't yet support this operation, the resource's service might support tagging
using its own API operations. For more information, refer to the documentation for that
service. Each resource can have up to 50 tags. For other limits, see Tag Naming and Usage
Conventions in the AWS General Reference. You can only tag resources that are located in
the specified Amazon Web Services Region for the Amazon Web Services account. To add tags
to a resource, you need the necessary permissions for the service that the resource belongs
to as well as permissions for adding tags. For more information, see the documentation for
each service. Do not store personally identifiable information (PII) or other
confidential or sensitive information in tags. We use tags to provide you with billing and
administration services. Tags are not intended to be used for private or sensitive data.
Minimum permissions In addition to the tag:TagResources permission required by this
operation, you must also have the tagging permission defined by the service that created
the resource. For example, to tag a ChimeSDKMeetings instance using the TagResources
operation, you must have both of the following permissions: tag:TagResources
ChimeSDKMeetings:CreateTags Some services might have specific requirements for tagging
some resources. For example, to tag an Amazon S3 bucket, you must also have the
s3:GetBucketTagging permission. If the expected minimum permissions don't work, check the
documentation for that service's tagging APIs for more information.
- `"TenantIds"`: A consistent and opaque identifier, created and maintained by the builder
to represent a segment of their users.
"""
function create_meeting(
ClientRequestToken,
ExternalMeetingId,
MediaRegion;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings",
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"ExternalMeetingId" => ExternalMeetingId,
"MediaRegion" => MediaRegion,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_meeting(
ClientRequestToken,
ExternalMeetingId,
MediaRegion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"ExternalMeetingId" => ExternalMeetingId,
"MediaRegion" => MediaRegion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_meeting_with_attendees(attendees, client_request_token, external_meeting_id, media_region)
create_meeting_with_attendees(attendees, client_request_token, external_meeting_id, media_region, params::Dict{String,<:Any})
Creates a new Amazon Chime SDK meeting in the specified media Region, with attendees. For
more information about specifying media Regions, see Amazon Chime SDK Media Regions in the
Amazon Chime Developer Guide. For more information about the Amazon Chime SDK, see Using
the Amazon Chime SDK in the Amazon Chime Developer Guide.
# Arguments
- `attendees`: The attendee information, including attendees' IDs and join tokens.
- `client_request_token`: The unique identifier for the client request. Use a different
token for different meetings.
- `external_meeting_id`: The external meeting ID. Pattern:
[-_&@+=,(){}[]/«».:|'\"#a-zA-Z0-9À-ÿs]* Values that begin with aws: are reserved.
You can't configure a value that uses this prefix. Case insensitive.
- `media_region`: The Region in which to create the meeting. Available values: af-south-1,
ap-northeast-1, ap-northeast-2, ap-south-1, ap-southeast-1, ap-southeast-2, ca-central-1,
eu-central-1, eu-north-1, eu-south-1, eu-west-1, eu-west-2, eu-west-3, sa-east-1,
us-east-1, us-east-2, us-west-1, us-west-2. Available values in Amazon Web Services
GovCloud (US) Regions: us-gov-east-1, us-gov-west-1.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MeetingFeatures"`: Lists the audio and video features enabled for a meeting, such as
echo reduction.
- `"MeetingHostId"`: Reserved.
- `"NotificationsConfiguration"`: The configuration for resource targets to receive
notifications when meeting and attendee events occur.
- `"PrimaryMeetingId"`: When specified, replicates the media from the primary meeting to
the new meeting.
- `"Tags"`: The tags in the request.
- `"TenantIds"`: A consistent and opaque identifier, created and maintained by the builder
to represent a segment of their users.
"""
function create_meeting_with_attendees(
Attendees,
ClientRequestToken,
ExternalMeetingId,
MediaRegion;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings?operation=create-attendees",
Dict{String,Any}(
"Attendees" => Attendees,
"ClientRequestToken" => ClientRequestToken,
"ExternalMeetingId" => ExternalMeetingId,
"MediaRegion" => MediaRegion,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_meeting_with_attendees(
Attendees,
ClientRequestToken,
ExternalMeetingId,
MediaRegion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings?operation=create-attendees",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Attendees" => Attendees,
"ClientRequestToken" => ClientRequestToken,
"ExternalMeetingId" => ExternalMeetingId,
"MediaRegion" => MediaRegion,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_attendee(attendee_id, meeting_id)
delete_attendee(attendee_id, meeting_id, params::Dict{String,<:Any})
Deletes an attendee from the specified Amazon Chime SDK meeting and deletes their
JoinToken. Attendees are automatically deleted when a Amazon Chime SDK meeting is deleted.
For more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the
Amazon Chime Developer Guide.
# Arguments
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function delete_attendee(
AttendeeId, MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"DELETE",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_attendee(
AttendeeId,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"DELETE",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_meeting(meeting_id)
delete_meeting(meeting_id, params::Dict{String,<:Any})
Deletes the specified Amazon Chime SDK meeting. The operation deletes all attendees,
disconnects all clients, and prevents new clients from joining the meeting. For more
information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime
Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function delete_meeting(MeetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_meetings(
"DELETE",
"/meetings/$(MeetingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_meeting(
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"DELETE",
"/meetings/$(MeetingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_attendee(attendee_id, meeting_id)
get_attendee(attendee_id, meeting_id, params::Dict{String,<:Any})
Gets the Amazon Chime SDK attendee details for a specified meeting ID and attendee ID. For
more information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon
Chime Developer Guide.
# Arguments
- `attendee_id`: The Amazon Chime SDK attendee ID.
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function get_attendee(
AttendeeId, MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_attendee(
AttendeeId,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_meeting(meeting_id)
get_meeting(meeting_id, params::Dict{String,<:Any})
Gets the Amazon Chime SDK meeting details for the specified meeting ID. For more
information about the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime
Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
"""
function get_meeting(MeetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_meeting(
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_attendees(meeting_id)
list_attendees(meeting_id, params::Dict{String,<:Any})
Lists the attendees for the specified Amazon Chime SDK meeting. For more information about
the Amazon Chime SDK, see Using the Amazon Chime SDK in the Amazon Chime Developer Guide.
# Arguments
- `meeting_id`: The Amazon Chime SDK meeting ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token to use to retrieve the next page of results.
"""
function list_attendees(MeetingId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)/attendees";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_attendees(
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"GET",
"/meetings/$(MeetingId)/attendees",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Returns a list of the tags available for the specified resource.
# Arguments
- `arn`: The ARN of the resource.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_meetings(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_meeting_transcription(meeting_id, transcription_configuration)
start_meeting_transcription(meeting_id, transcription_configuration, params::Dict{String,<:Any})
Starts transcription for the specified meetingId. For more information, refer to Using
Amazon Chime SDK live transcription in the Amazon Chime SDK Developer Guide. If you
specify an invalid configuration, a TranscriptFailed event will be sent with the contents
of the BadRequestException generated by Amazon Transcribe. For more information on each
parameter and which combinations are valid, refer to the StartStreamTranscription API in
the Amazon Transcribe Developer Guide. By default, Amazon Transcribe may use and store
audio content processed by the service to develop and improve Amazon Web Services AI/ML
services as further described in section 50 of the Amazon Web Services Service Terms. Using
Amazon Transcribe may be subject to federal and state laws or regulations regarding the
recording or interception of electronic communications. It is your and your end users’
responsibility to comply with all applicable laws regarding the recording, including
properly notifying all participants in a recorded session or communication that the session
or communication is being recorded, and obtaining all necessary consents. You can opt out
from Amazon Web Services using audio content to develop and improve AWS AI/ML services by
configuring an AI services opt out policy using Amazon Web Services Organizations.
# Arguments
- `meeting_id`: The unique ID of the meeting being transcribed.
- `transcription_configuration`: The configuration for the current transcription operation.
Must contain EngineTranscribeSettings or EngineTranscribeMedicalSettings.
"""
function start_meeting_transcription(
MeetingId, TranscriptionConfiguration; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/transcription?operation=start",
Dict{String,Any}("TranscriptionConfiguration" => TranscriptionConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_meeting_transcription(
MeetingId,
TranscriptionConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/transcription?operation=start",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TranscriptionConfiguration" => TranscriptionConfiguration
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_meeting_transcription(meeting_id)
stop_meeting_transcription(meeting_id, params::Dict{String,<:Any})
Stops transcription for the specified meetingId. For more information, refer to Using
Amazon Chime SDK live transcription in the Amazon Chime SDK Developer Guide. By default,
Amazon Transcribe may use and store audio content processed by the service to develop and
improve Amazon Web Services AI/ML services as further described in section 50 of the Amazon
Web Services Service Terms. Using Amazon Transcribe may be subject to federal and state
laws or regulations regarding the recording or interception of electronic communications.
It is your and your end users’ responsibility to comply with all applicable laws
regarding the recording, including properly notifying all participants in a recorded
session or communication that the session or communication is being recorded, and obtaining
all necessary consents. You can opt out from Amazon Web Services using audio content to
develop and improve Amazon Web Services AI/ML services by configuring an AI services opt
out policy using Amazon Web Services Organizations.
# Arguments
- `meeting_id`: The unique ID of the meeting for which you stop transcription.
"""
function stop_meeting_transcription(
MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/transcription?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_meeting_transcription(
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/meetings/$(MeetingId)/transcription?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
The resource that supports tags.
# Arguments
- `resource_arn`: The ARN of the resource.
- `tags`: Lists the requested tags.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_meetings(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the specified tags from the specified resources. When you specify a tag key, the
action removes both that key and its associated value. The operation succeeds even if you
attempt to remove tags from a resource that were already removed. Note the following: To
remove tags from a resource, you need the necessary permissions for the service that the
resource belongs to as well as permissions for removing tags. For more information, see the
documentation for the service whose resource you want to untag. You can only tag
resources that are located in the specified Amazon Web Services Region for the calling
Amazon Web Services account. Minimum permissions In addition to the tag:UntagResources
permission required by this operation, you must also have the remove tags permission
defined by the service that created the resource. For example, to remove the tags from an
Amazon EC2 instance using the UntagResources operation, you must have both of the following
permissions: tag:UntagResource ChimeSDKMeetings:DeleteTags
# Arguments
- `resource_arn`: The ARN of the resource that you're removing tags from.
- `tag_keys`: The tag keys being removed from the resources.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_attendee_capabilities(attendee_id, capabilities, meeting_id)
update_attendee_capabilities(attendee_id, capabilities, meeting_id, params::Dict{String,<:Any})
The capabilities that you want to update. You use the capabilities with a set of values
that control what the capabilities can do, such as SendReceive data. For more information
about those values, see . When using capabilities, be aware of these corner cases: If
you specify MeetingFeatures:Video:MaxResolution:None when you create a meeting, all API
requests that include SendReceive, Send, or Receive for AttendeeCapabilities:Video will be
rejected with ValidationError 400. If you specify
MeetingFeatures:Content:MaxResolution:None when you create a meeting, all API requests that
include SendReceive, Send, or Receive for AttendeeCapabilities:Content will be rejected
with ValidationError 400. You can't set content capabilities to SendReceive or Receive
unless you also set video capabilities to SendReceive or Receive. If you don't set the
video capability to receive, the response will contain an HTTP 400 Bad Request status code.
However, you can set your video capability to receive and you set your content capability
to not receive. When you change an audio capability from None or Receive to Send or
SendReceive , and if the attendee left their microphone unmuted, audio will flow from the
attendee to the other meeting participants. When you change a video or content capability
from None or Receive to Send or SendReceive , and if the attendee turned on their video or
content streams, remote attendees can receive those streams, but only after media
renegotiation between the client and the Amazon Chime back-end server.
# Arguments
- `attendee_id`: The ID of the attendee associated with the update request.
- `capabilities`: The capabilities that you want to update.
- `meeting_id`: The ID of the meeting associated with the update request.
"""
function update_attendee_capabilities(
AttendeeId, Capabilities, MeetingId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_meetings(
"PUT",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)/capabilities",
Dict{String,Any}("Capabilities" => Capabilities);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_attendee_capabilities(
AttendeeId,
Capabilities,
MeetingId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_meetings(
"PUT",
"/meetings/$(MeetingId)/attendees/$(AttendeeId)/capabilities",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Capabilities" => Capabilities), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 96697 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime_sdk_messaging
using AWS.Compat
using AWS.UUIDs
"""
associate_channel_flow(channel_flow_arn, channel_arn, x-amz-chime-bearer)
associate_channel_flow(channel_flow_arn, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Associates a channel flow with a channel. Once associated, all messages to that channel go
through channel flow processors. To stop processing, use the DisassociateChannelFlow API.
Only administrators or channel moderators can associate a channel flow. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_flow_arn`: The ARN of the channel flow.
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The AppInstanceUserArn of the user making the API call.
"""
function associate_channel_flow(
ChannelFlowArn,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/channel-flow",
Dict{String,Any}(
"ChannelFlowArn" => ChannelFlowArn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_channel_flow(
ChannelFlowArn,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/channel-flow",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChannelFlowArn" => ChannelFlowArn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_create_channel_membership(member_arns, channel_arn, x-amz-chime-bearer)
batch_create_channel_membership(member_arns, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Adds a specified number of users and bots to a channel.
# Arguments
- `member_arns`: The ARNs of the members you want to add to the channel. Only
AppInstanceUsers and AppInstanceBots can be added as a channel member.
- `channel_arn`: The ARN of the channel to which you're adding users or bots.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SubChannelId"`: The ID of the SubChannel in the request. Only required when creating
membership in a SubChannel for a moderator in an elastic channel.
- `"Type"`: The membership type of a user, DEFAULT or HIDDEN. Default members are always
returned as part of ListChannelMemberships. Hidden members are only returned if the type
filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned.
This is only supported by moderators.
"""
function batch_create_channel_membership(
MemberArns,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/memberships?operation=batch-create",
Dict{String,Any}(
"MemberArns" => MemberArns,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_create_channel_membership(
MemberArns,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/memberships?operation=batch-create",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"MemberArns" => MemberArns,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
channel_flow_callback(callback_id, channel_message, channel_arn)
channel_flow_callback(callback_id, channel_message, channel_arn, params::Dict{String,<:Any})
Calls back Amazon Chime SDK messaging with a processing response message. This should be
invoked from the processor Lambda. This is a developer API. You can return one of the
following processing responses: Update message content or metadata Deny a message
Make no changes to the message
# Arguments
- `callback_id`: The identifier passed to the processor by the service when invoked. Use
the identifier to call back the service.
- `channel_message`: Stores information about the processed message.
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DeleteResource"`: When a processor determines that a message needs to be DENIED, pass
this parameter with a value of true.
"""
function channel_flow_callback(
CallbackId,
ChannelMessage,
channelArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)?operation=channel-flow-callback",
Dict{String,Any}("CallbackId" => CallbackId, "ChannelMessage" => ChannelMessage);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function channel_flow_callback(
CallbackId,
ChannelMessage,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)?operation=channel-flow-callback",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CallbackId" => CallbackId, "ChannelMessage" => ChannelMessage
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel(app_instance_arn, client_request_token, name, x-amz-chime-bearer)
create_channel(app_instance_arn, client_request_token, name, x-amz-chime-bearer, params::Dict{String,<:Any})
Creates a channel to which you can add users and send messages. Restriction: You can't
change a channel's privacy. The x-amz-chime-bearer request header is mandatory. Use the
ARN of the AppInstanceUser or AppInstanceBot that makes the API call as the value in the
header.
# Arguments
- `app_instance_arn`: The ARN of the channel request.
- `client_request_token`: The client token for the request. An Idempotency token.
- `name`: The name of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChannelId"`: The ID of the channel in the request.
- `"ElasticChannelConfiguration"`: The attributes required to configure and create an
elastic channel. An elastic channel can support a maximum of 1-million users, excluding
moderators.
- `"ExpirationSettings"`: Settings that control the interval after which the channel is
automatically deleted.
- `"MemberArns"`: The ARNs of the channel members in the request.
- `"Metadata"`: The metadata of the creation request. Limited to 1KB and UTF-8.
- `"Mode"`: The channel mode: UNRESTRICTED or RESTRICTED. Administrators, moderators, and
channel members can add themselves and other members to unrestricted channels. Only
administrators and moderators can add members to restricted channels.
- `"ModeratorArns"`: The ARNs of the channel moderators in the request.
- `"Privacy"`: The channel's privacy level: PUBLIC or PRIVATE. Private channels aren't
discoverable by users outside the channel. Public channels are discoverable by anyone in
the AppInstance.
- `"Tags"`: The tags for the creation request.
"""
function create_channel(
AppInstanceArn,
ClientRequestToken,
Name,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel(
AppInstanceArn,
ClientRequestToken,
Name,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_ban(member_arn, channel_arn, x-amz-chime-bearer)
create_channel_ban(member_arn, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Permanently bans a member from a channel. Moderators can't add banned members to a channel.
To undo a ban, you first have to DeleteChannelBan, and then CreateChannelMembership. Bans
are cleaned up when you delete users or channels. If you ban a user who is already part of
a channel, that user is automatically kicked from the channel. The x-amz-chime-bearer
request header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that
makes the API call as the value in the header.
# Arguments
- `member_arn`: The AppInstanceUserArn of the member being banned.
- `channel_arn`: The ARN of the ban request.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function create_channel_ban(
MemberArn,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/bans",
Dict{String,Any}(
"MemberArn" => MemberArn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_ban(
MemberArn,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/bans",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"MemberArn" => MemberArn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_flow(app_instance_arn, client_request_token, name, processors)
create_channel_flow(app_instance_arn, client_request_token, name, processors, params::Dict{String,<:Any})
Creates a channel flow, a container for processors. Processors are AWS Lambda functions
that perform actions on chat messages, such as stripping out profanity. You can associate
channel flows with channels, and the processors in the channel flow then take action on all
messages sent to that channel. This is a developer API. Channel flows process the following
items: New and updated messages Persistent and non-persistent messages The Standard
message type Channel flows don't process Control or System messages. For more
information about the message types provided by Chime SDK messaging, refer to Message types
in the Amazon Chime developer guide.
# Arguments
- `app_instance_arn`: The ARN of the channel flow request.
- `client_request_token`: The client token for the request. An Idempotency token.
- `name`: The name of the channel flow.
- `processors`: Information about the processor Lambda functions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tags for the creation request.
"""
function create_channel_flow(
AppInstanceArn,
ClientRequestToken,
Name,
Processors;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channel-flows",
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
"Processors" => Processors,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_flow(
AppInstanceArn,
ClientRequestToken,
Name,
Processors,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channel-flows",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AppInstanceArn" => AppInstanceArn,
"ClientRequestToken" => ClientRequestToken,
"Name" => Name,
"Processors" => Processors,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_membership(member_arn, type, channel_arn, x-amz-chime-bearer)
create_channel_membership(member_arn, type, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Adds a member to a channel. The InvitedBy field in ChannelMembership is derived from the
request header. A channel member can: List messages Send messages Receive messages
Edit their own messages Leave the channel Privacy settings impact this action as
follows: Public Channels: You do not need to be a member to list messages, but you must
be a member to send messages. Private Channels: You must be a member to list or send
messages. The x-amz-chime-bearer request header is mandatory. Use the ARN of the
AppInstanceUserArn or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `member_arn`: The AppInstanceUserArn of the member you want to add to the channel.
- `type`: The membership type of a user, DEFAULT or HIDDEN. Default members are always
returned as part of ListChannelMemberships. Hidden members are only returned if the type
filter in ListChannelMemberships equals HIDDEN. Otherwise hidden members are not returned.
This is only supported by moderators.
- `channel_arn`: The ARN of the channel to which you're adding users.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SubChannelId"`: The ID of the SubChannel in the request. Only required when creating
membership in a SubChannel for a moderator in an elastic channel.
"""
function create_channel_membership(
MemberArn,
Type,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/memberships",
Dict{String,Any}(
"MemberArn" => MemberArn,
"Type" => Type,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_membership(
MemberArn,
Type,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/memberships",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"MemberArn" => MemberArn,
"Type" => Type,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel_moderator(channel_moderator_arn, channel_arn, x-amz-chime-bearer)
create_channel_moderator(channel_moderator_arn, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Creates a new ChannelModerator. A channel moderator can: Add and remove other members of
the channel. Add and remove other moderators of the channel. Add and remove user bans
for the channel. Redact messages in the channel. List messages in the channel. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBotof the user that makes the API call as the value in the header.
# Arguments
- `channel_moderator_arn`: The AppInstanceUserArn of the moderator.
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function create_channel_moderator(
ChannelModeratorArn,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/moderators",
Dict{String,Any}(
"ChannelModeratorArn" => ChannelModeratorArn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel_moderator(
ChannelModeratorArn,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/moderators",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChannelModeratorArn" => ChannelModeratorArn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel(channel_arn, x-amz-chime-bearer)
delete_channel(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Immediately makes a channel and its memberships inaccessible and marks them for deletion.
This is an irreversible process. The x-amz-chime-bearer request header is mandatory. Use
the ARN of the AppInstanceUserArn or AppInstanceBot that makes the API call as the value in
the header.
# Arguments
- `channel_arn`: The ARN of the channel being deleted.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function delete_channel(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_ban(channel_arn, member_arn, x-amz-chime-bearer)
delete_channel_ban(channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Removes a member from a channel's ban list. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel from which the AppInstanceUser was banned.
- `member_arn`: The ARN of the AppInstanceUser that you want to reinstate.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function delete_channel_ban(
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/bans/$(memberArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_ban(
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/bans/$(memberArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_flow(channel_flow_arn)
delete_channel_flow(channel_flow_arn, params::Dict{String,<:Any})
Deletes a channel flow, an irreversible process. This is a developer API. This API works
only when the channel flow is not associated with any channel. To get a list of all
channels that a channel flow is associated with, use the
ListChannelsAssociatedWithChannelFlow API. Use the DisassociateChannelFlow API to
disassociate a channel flow from all channels.
# Arguments
- `channel_flow_arn`: The ARN of the channel flow.
"""
function delete_channel_flow(
channelFlowArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"DELETE",
"/channel-flows/$(channelFlowArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_flow(
channelFlowArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channel-flows/$(channelFlowArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_membership(channel_arn, member_arn, x-amz-chime-bearer)
delete_channel_membership(channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Removes a member from a channel. The x-amz-chime-bearer request header is mandatory. Use
the AppInstanceUserArn of the user that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel from which you want to remove the user.
- `member_arn`: The AppInstanceUserArn of the member that you're removing from the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only for use by moderators.
"""
function delete_channel_membership(
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/memberships/$(memberArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_membership(
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/memberships/$(memberArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_message(channel_arn, message_id, x-amz-chime-bearer)
delete_channel_message(channel_arn, message_id, x-amz-chime-bearer, params::Dict{String,<:Any})
Deletes a channel message. Only admins can perform this action. Deletion makes messages
inaccessible immediately. A background process deletes any revisions created by
UpdateChannelMessage. The x-amz-chime-bearer request header is mandatory. Use the ARN of
the AppInstanceUser or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID of the message being deleted.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only required when deleting
messages in a SubChannel that the user belongs to.
"""
function delete_channel_message(
channelArn,
messageId,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_message(
channelArn,
messageId,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel_moderator(channel_arn, channel_moderator_arn, x-amz-chime-bearer)
delete_channel_moderator(channel_arn, channel_moderator_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Deletes a channel moderator. The x-amz-chime-bearer request header is mandatory. Use the
ARN of the AppInstanceUser or AppInstanceBot that makes the API call as the value in the
header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `channel_moderator_arn`: The AppInstanceUserArn of the moderator being deleted.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function delete_channel_moderator(
channelArn,
channelModeratorArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel_moderator(
channelArn,
channelModeratorArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_messaging_streaming_configurations(app_instance_arn)
delete_messaging_streaming_configurations(app_instance_arn, params::Dict{String,<:Any})
Deletes the streaming configurations for an AppInstance. For more information, see
Streaming messaging data in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the streaming configurations being deleted.
"""
function delete_messaging_streaming_configurations(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"DELETE",
"/app-instances/$(appInstanceArn)/streaming-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_messaging_streaming_configurations(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/app-instances/$(appInstanceArn)/streaming-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel(channel_arn, x-amz-chime-bearer)
describe_channel(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the full details of a channel in an Amazon Chime AppInstance. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function describe_channel(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_ban(channel_arn, member_arn, x-amz-chime-bearer)
describe_channel_ban(channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the full details of a channel ban. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel from which the user is banned.
- `member_arn`: The AppInstanceUserArn of the member being banned.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function describe_channel_ban(
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/bans/$(memberArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_ban(
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/bans/$(memberArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_flow(channel_flow_arn)
describe_channel_flow(channel_flow_arn, params::Dict{String,<:Any})
Returns the full details of a channel flow in an Amazon Chime AppInstance. This is a
developer API.
# Arguments
- `channel_flow_arn`: The ARN of the channel flow.
"""
function describe_channel_flow(
channelFlowArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channel-flows/$(channelFlowArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_flow(
channelFlowArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channel-flows/$(channelFlowArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_membership(channel_arn, member_arn, x-amz-chime-bearer)
describe_channel_membership(channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the full details of a user's channel membership. The x-amz-chime-bearer request
header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the
API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `member_arn`: The AppInstanceUserArn of the member.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sub-channel-id"`: The ID of the SubChannel in the request. The response contains an
ElasticChannelConfiguration object. Only required to get a user’s SubChannel membership
details.
"""
function describe_channel_membership(
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_membership(
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_membership_for_app_instance_user(app-instance-user-arn, channel_arn, x-amz-chime-bearer)
describe_channel_membership_for_app_instance_user(app-instance-user-arn, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the details of a channel based on the membership of the specified AppInstanceUser
or AppInstanceBot. The x-amz-chime-bearer request header is mandatory. Use the ARN of the
AppInstanceUser or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `app-instance-user-arn`: The ARN of the user or bot in a channel.
- `channel_arn`: The ARN of the channel to which the user belongs.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function describe_channel_membership_for_app_instance_user(
app_instance_user_arn,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-membership",
Dict{String,Any}(
"app-instance-user-arn" => app_instance_user_arn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_membership_for_app_instance_user(
app_instance_user_arn,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-membership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"app-instance-user-arn" => app_instance_user_arn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_moderated_by_app_instance_user(app-instance-user-arn, channel_arn, x-amz-chime-bearer)
describe_channel_moderated_by_app_instance_user(app-instance-user-arn, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the full details of a channel moderated by the specified AppInstanceUser or
AppInstanceBot. The x-amz-chime-bearer request header is mandatory. Use the ARN of the
AppInstanceUser or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `app-instance-user-arn`: The ARN of the user or bot in the moderated channel.
- `channel_arn`: The ARN of the moderated channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function describe_channel_moderated_by_app_instance_user(
app_instance_user_arn,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-moderated-channel",
Dict{String,Any}(
"app-instance-user-arn" => app_instance_user_arn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_moderated_by_app_instance_user(
app_instance_user_arn,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)?scope=app-instance-user-moderated-channel",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"app-instance-user-arn" => app_instance_user_arn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_channel_moderator(channel_arn, channel_moderator_arn, x-amz-chime-bearer)
describe_channel_moderator(channel_arn, channel_moderator_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Returns the full details of a single ChannelModerator. The x-amz-chime-bearer request
header is mandatory. Use the AppInstanceUserArn of the user that makes the API call as the
value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `channel_moderator_arn`: The AppInstanceUserArn of the channel moderator.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function describe_channel_moderator(
channelArn,
channelModeratorArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_channel_moderator(
channelArn,
channelModeratorArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/moderators/$(channelModeratorArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_channel_flow(channel_arn, channel_flow_arn, x-amz-chime-bearer)
disassociate_channel_flow(channel_arn, channel_flow_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Disassociates a channel flow from all its channels. Once disassociated, all messages to
that channel stop going through the channel flow processor. Only administrators or channel
moderators can disassociate a channel flow. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `channel_flow_arn`: The ARN of the channel flow.
- `x-amz-chime-bearer`: The AppInstanceUserArn of the user making the API call.
"""
function disassociate_channel_flow(
channelArn,
channelFlowArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/channel-flow/$(channelFlowArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_channel_flow(
channelArn,
channelFlowArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"DELETE",
"/channels/$(channelArn)/channel-flow/$(channelFlowArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_channel_membership_preferences(channel_arn, member_arn, x-amz-chime-bearer)
get_channel_membership_preferences(channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Gets the membership preferences of an AppInstanceUser or AppInstanceBot for the specified
channel. A user or a bot must be a member of the channel and own the membership in order to
retrieve membership preferences. Users or bots in the AppInstanceAdmin and channel
moderator roles can't retrieve preferences for other users or bots. Banned users or bots
can't retrieve membership preferences for the channel from which they are banned. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `member_arn`: The AppInstanceUserArn of the member retrieving the preferences.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function get_channel_membership_preferences(
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)/preferences",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_channel_membership_preferences(
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships/$(memberArn)/preferences",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_channel_message(channel_arn, message_id, x-amz-chime-bearer)
get_channel_message(channel_arn, message_id, x-amz-chime-bearer, params::Dict{String,<:Any})
Gets the full details of a channel message. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID of the message.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only required when getting
messages in a SubChannel that the user belongs to.
"""
function get_channel_message(
channelArn,
messageId,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_channel_message(
channelArn,
messageId,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_channel_message_status(channel_arn, message_id, x-amz-chime-bearer)
get_channel_message_status(channel_arn, message_id, x-amz-chime-bearer, params::Dict{String,<:Any})
Gets message status for a specified messageId. Use this API to determine the intermediate
status of messages going through channel flow processing. The API provides an alternative
to retrieving message status if the event was not received because a client wasn't
connected to a websocket. Messages can have any one of these statuses. SENT Message
processed successfully PENDING Ongoing processing FAILED Processing failed DENIED
Message denied by the processor This API does not return statuses for denied messages,
because we don't store them once the processor denies them. Only the message sender can
invoke this API. The x-amz-chime-bearer request header is mandatory. Use the ARN of the
AppInstanceUser or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel
- `message_id`: The ID of the message.
- `x-amz-chime-bearer`: The AppInstanceUserArn of the user making the API call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only required when getting
message status in a SubChannel that the user belongs to.
"""
function get_channel_message_status(
channelArn,
messageId,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages/$(messageId)?scope=message-status",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_channel_message_status(
channelArn,
messageId,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages/$(messageId)?scope=message-status",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_messaging_session_endpoint()
get_messaging_session_endpoint(params::Dict{String,<:Any})
The details of the endpoint for the messaging session.
"""
function get_messaging_session_endpoint(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_messaging(
"GET",
"/endpoints/messaging-session";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_messaging_session_endpoint(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/endpoints/messaging-session",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_messaging_streaming_configurations(app_instance_arn)
get_messaging_streaming_configurations(app_instance_arn, params::Dict{String,<:Any})
Retrieves the data streaming configuration for an AppInstance. For more information, see
Streaming messaging data in the Amazon Chime SDK Developer Guide.
# Arguments
- `app_instance_arn`: The ARN of the streaming configurations.
"""
function get_messaging_streaming_configurations(
appInstanceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/app-instances/$(appInstanceArn)/streaming-configurations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_messaging_streaming_configurations(
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/app-instances/$(appInstanceArn)/streaming-configurations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_bans(channel_arn, x-amz-chime-bearer)
list_channel_bans(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all the users and bots banned from a particular channel. The x-amz-chime-bearer
request header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that
makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of bans that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested bans are
returned.
"""
function list_channel_bans(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/bans",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_bans(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/bans",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_flows(app-instance-arn)
list_channel_flows(app-instance-arn, params::Dict{String,<:Any})
Returns a paginated lists of all the channel flows created under a single Chime. This is a
developer API.
# Arguments
- `app-instance-arn`: The ARN of the app instance.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channel flows that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested channel flows
are returned.
"""
function list_channel_flows(
app_instance_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channel-flows",
Dict{String,Any}("app-instance-arn" => app_instance_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_flows(
app_instance_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channel-flows",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("app-instance-arn" => app_instance_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_memberships(channel_arn, x-amz-chime-bearer)
list_channel_memberships(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all channel memberships in a channel. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header. If you want to list the channels to which a specific app instance
user belongs, see the ListChannelMembershipsForAppInstanceUser API.
# Arguments
- `channel_arn`: The maximum number of channel memberships that you want returned.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channel memberships that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested channel
memberships are returned.
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only required when listing
a user's memberships in a particular sub-channel of an elastic channel.
- `"type"`: The membership type of a user, DEFAULT or HIDDEN. Default members are returned
as part of ListChannelMemberships if no type is specified. Hidden members are only returned
if the type filter in ListChannelMemberships equals HIDDEN.
"""
function list_channel_memberships(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_memberships(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/memberships",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_memberships_for_app_instance_user(x-amz-chime-bearer)
list_channel_memberships_for_app_instance_user(x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all channels that an AppInstanceUser or AppInstanceBot is a part of. Only an
AppInstanceAdmin can call the API with a user ARN that is not their own. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"app-instance-user-arn"`: The ARN of the user or bot.
- `"max-results"`: The maximum number of users that you want returned.
- `"next-token"`: The token returned from previous API requests until the number of channel
memberships is reached.
"""
function list_channel_memberships_for_app_instance_user(
x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels?scope=app-instance-user-memberships",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_memberships_for_app_instance_user(
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels?scope=app-instance-user-memberships",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_messages(channel_arn, x-amz-chime-bearer)
list_channel_messages(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
List all the messages in a channel. Returns a paginated list of ChannelMessages. By
default, sorted by creation timestamp in descending order. Redacted messages appear in the
results as empty, since they are only redacted, not deleted. Deleted messages do not appear
in the results. This action always returns the latest version of an edited message. Also,
the x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of messages that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested messages are
returned.
- `"not-after"`: The final or ending time stamp for your requested messages.
- `"not-before"`: The initial or starting time stamp for your requested messages.
- `"sort-order"`: The order in which you want messages sorted. Default is Descending, based
on time created.
- `"sub-channel-id"`: The ID of the SubChannel in the request. Only required when listing
the messages in a SubChannel that the user belongs to.
"""
function list_channel_messages(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_messages(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channel_moderators(channel_arn, x-amz-chime-bearer)
list_channel_moderators(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all the moderators for a channel. The x-amz-chime-bearer request header is
mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as
the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of moderators that you want returned.
- `"next-token"`: The token passed by previous API calls until all requested moderators are
returned.
"""
function list_channel_moderators(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/moderators",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channel_moderators(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/moderators",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels(app-instance-arn, x-amz-chime-bearer)
list_channels(app-instance-arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all Channels created under a single Chime App as a paginated list. You can specify
filters to narrow results. Functionality & restrictions Use privacy = PUBLIC to
retrieve all public channels in the account. Only an AppInstanceAdmin can set privacy =
PRIVATE to list the private channels in an account. The x-amz-chime-bearer request
header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the
API call as the value in the header.
# Arguments
- `app-instance-arn`: The ARN of the AppInstance.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channels that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested channels are
returned.
- `"privacy"`: The privacy setting. PUBLIC retrieves all the public channels. PRIVATE
retrieves private channels. Only an AppInstanceAdmin can retrieve private channels.
"""
function list_channels(
app_instance_arn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels",
Dict{String,Any}(
"app-instance-arn" => app_instance_arn,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channels(
app_instance_arn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"app-instance-arn" => app_instance_arn,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels_associated_with_channel_flow(channel-flow-arn)
list_channels_associated_with_channel_flow(channel-flow-arn, params::Dict{String,<:Any})
Lists all channels associated with a specified channel flow. You can associate a channel
flow with multiple channels, but you can only associate a channel with one channel flow.
This is a developer API.
# Arguments
- `channel-flow-arn`: The ARN of the channel flow.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channels that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested channels are
returned.
"""
function list_channels_associated_with_channel_flow(
channel_flow_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels?scope=channel-flow-associations",
Dict{String,Any}("channel-flow-arn" => channel_flow_arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channels_associated_with_channel_flow(
channel_flow_arn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels?scope=channel-flow-associations",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("channel-flow-arn" => channel_flow_arn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels_moderated_by_app_instance_user(x-amz-chime-bearer)
list_channels_moderated_by_app_instance_user(x-amz-chime-bearer, params::Dict{String,<:Any})
A list of the channels moderated by an AppInstanceUser. The x-amz-chime-bearer request
header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that makes the
API call as the value in the header.
# Arguments
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"app-instance-user-arn"`: The ARN of the user or bot in the moderated channel.
- `"max-results"`: The maximum number of channels in the request.
- `"next-token"`: The token returned from previous API requests until the number of
channels moderated by the user is reached.
"""
function list_channels_moderated_by_app_instance_user(
x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels?scope=app-instance-user-moderated-channels",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_channels_moderated_by_app_instance_user(
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels?scope=app-instance-user-moderated-channels",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sub_channels(channel_arn, x-amz-chime-bearer)
list_sub_channels(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Lists all the SubChannels in an elastic channel when given a channel ID. Available only to
the app instance admins and channel moderators of elastic channels.
# Arguments
- `channel_arn`: The ARN of elastic channel.
- `x-amz-chime-bearer`: The AppInstanceUserArn of the user making the API call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of sub-channels that you want to return.
- `"next-token"`: The token passed by previous API calls until all requested sub-channels
are returned.
"""
function list_sub_channels(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/subchannels",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sub_channels(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"GET",
"/channels/$(channelArn)/subchannels",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Lists the tags applied to an Amazon Chime SDK messaging resource.
# Arguments
- `arn`: The ARN of the resource.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_messaging(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_channel_expiration_settings(channel_arn)
put_channel_expiration_settings(channel_arn, params::Dict{String,<:Any})
Sets the number of days before the channel is automatically deleted. A background
process deletes expired channels within 6 hours of expiration. Actual deletion times may
vary. Expired channels that have not yet been deleted appear as active, and you can
update their expiration settings. The system honors the new settings. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpirationSettings"`: Settings that control the interval after which a channel is
deleted.
- `"x-amz-chime-bearer"`: The ARN of the AppInstanceUser or AppInstanceBot that makes the
API call.
"""
function put_channel_expiration_settings(
channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/expiration-settings";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_channel_expiration_settings(
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/expiration-settings",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_channel_membership_preferences(preferences, channel_arn, member_arn, x-amz-chime-bearer)
put_channel_membership_preferences(preferences, channel_arn, member_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Sets the membership preferences of an AppInstanceUser or AppInstanceBot for the specified
channel. The user or bot must be a member of the channel. Only the user or bot who owns the
membership can set preferences. Users or bots in the AppInstanceAdmin and channel moderator
roles can't set preferences for other users. Banned users or bots can't set membership
preferences for the channel from which they are banned. The x-amz-chime-bearer request
header is mandatory. Use the ARN of an AppInstanceUser or AppInstanceBot that makes the API
call as the value in the header.
# Arguments
- `preferences`: The channel membership preferences of an AppInstanceUser .
- `channel_arn`: The ARN of the channel.
- `member_arn`: The ARN of the member setting the preferences.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function put_channel_membership_preferences(
Preferences,
channelArn,
memberArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/memberships/$(memberArn)/preferences",
Dict{String,Any}(
"Preferences" => Preferences,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_channel_membership_preferences(
Preferences,
channelArn,
memberArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/memberships/$(memberArn)/preferences",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Preferences" => Preferences,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_messaging_streaming_configurations(streaming_configurations, app_instance_arn)
put_messaging_streaming_configurations(streaming_configurations, app_instance_arn, params::Dict{String,<:Any})
Sets the data streaming configuration for an AppInstance. For more information, see
Streaming messaging data in the Amazon Chime SDK Developer Guide.
# Arguments
- `streaming_configurations`: The streaming configurations.
- `app_instance_arn`: The ARN of the streaming configuration.
"""
function put_messaging_streaming_configurations(
StreamingConfigurations,
appInstanceArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/app-instances/$(appInstanceArn)/streaming-configurations",
Dict{String,Any}("StreamingConfigurations" => StreamingConfigurations);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_messaging_streaming_configurations(
StreamingConfigurations,
appInstanceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/app-instances/$(appInstanceArn)/streaming-configurations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("StreamingConfigurations" => StreamingConfigurations),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
redact_channel_message(channel_arn, message_id, x-amz-chime-bearer)
redact_channel_message(channel_arn, message_id, x-amz-chime-bearer, params::Dict{String,<:Any})
Redacts message content, but not metadata. The message exists in the back end, but the
action returns null content, and the state shows as redacted. The x-amz-chime-bearer
request header is mandatory. Use the ARN of the AppInstanceUser or AppInstanceBot that
makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel containing the messages that you want to redact.
- `message_id`: The ID of the message being redacted.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SubChannelId"`: The ID of the SubChannel in the request.
"""
function redact_channel_message(
channelArn,
messageId,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/messages/$(messageId)?operation=redact",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function redact_channel_message(
channelArn,
messageId,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/messages/$(messageId)?operation=redact",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_channels(fields)
search_channels(fields, params::Dict{String,<:Any})
Allows the ChimeBearer to search channels by channel members. Users or bots can search
across the channels that they belong to. Users in the AppInstanceAdmin role can search
across all channels. The x-amz-chime-bearer request header is mandatory. Use the ARN of the
AppInstanceUser or AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `fields`: A list of the Field objects in the channel being searched.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of channels that you want returned.
- `"next-token"`: The token returned from previous API requests until the number of
channels is reached.
- `"x-amz-chime-bearer"`: The AppInstanceUserArn of the user making the API call.
"""
function search_channels(Fields; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_messaging(
"POST",
"/channels?operation=search",
Dict{String,Any}("Fields" => Fields);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_channels(
Fields, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"POST",
"/channels?operation=search",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Fields" => Fields), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
send_channel_message(client_request_token, content, persistence, type, channel_arn, x-amz-chime-bearer)
send_channel_message(client_request_token, content, persistence, type, channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Sends a message to a particular channel that the member is a part of. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header. Also, STANDARD messages
can be up to 4KB in size and contain metadata. Metadata is arbitrary, and you can use it in
a variety of ways, such as containing a link to an attachment. CONTROL messages are
limited to 30 bytes and do not contain metadata.
# Arguments
- `client_request_token`: The Idempotency token for each client request.
- `content`: The content of the channel message.
- `persistence`: Boolean that controls whether the message is persisted on the back end.
Required.
- `type`: The type of message, STANDARD or CONTROL. STANDARD messages can be up to 4KB in
size and contain metadata. Metadata is arbitrary, and you can use it in a variety of ways,
such as containing a link to an attachment. CONTROL messages are limited to 30 bytes and
do not contain metadata.
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ContentType"`: The content type of the channel message.
- `"MessageAttributes"`: The attributes for the message, used for message filtering along
with a FilterRule defined in the PushNotificationPreferences.
- `"Metadata"`: The optional metadata for each message.
- `"PushNotification"`: The push notification configuration of the message.
- `"SubChannelId"`: The ID of the SubChannel in the request.
- `"Target"`: The target of a message. Must be a member of the channel, such as another
user, a bot, or the sender. Only the target and the sender can view targeted messages. Only
users who can see targeted messages can take actions on them. However, administrators can
delete targeted messages that they can’t see.
"""
function send_channel_message(
ClientRequestToken,
Content,
Persistence,
Type,
channelArn,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"Content" => Content,
"Persistence" => Persistence,
"Type" => Type,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function send_channel_message(
ClientRequestToken,
Content,
Persistence,
Type,
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/channels/$(channelArn)/messages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientRequestToken" => ClientRequestToken,
"Content" => Content,
"Persistence" => Persistence,
"Type" => Type,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Applies the specified tags to the specified Amazon Chime SDK messaging resource.
# Arguments
- `resource_arn`: The resource ARN.
- `tags`: The tag key-value pairs.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_messaging(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes the specified tags from the specified Amazon Chime SDK messaging resource.
# Arguments
- `resource_arn`: The resource ARN.
- `tag_keys`: The tag keys.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel(channel_arn, x-amz-chime-bearer)
update_channel(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
Update a channel's attributes. Restriction: You can't change a channel's privacy. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Metadata"`: The metadata for the update request.
- `"Mode"`: The mode of the update request.
- `"Name"`: The name of the channel.
"""
function update_channel(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel_flow(name, processors, channel_flow_arn)
update_channel_flow(name, processors, channel_flow_arn, params::Dict{String,<:Any})
Updates channel flow attributes. This is a developer API.
# Arguments
- `name`: The name of the channel flow.
- `processors`: Information about the processor Lambda functions
- `channel_flow_arn`: The ARN of the channel flow.
"""
function update_channel_flow(
Name, Processors, channelFlowArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"PUT",
"/channel-flows/$(channelFlowArn)",
Dict{String,Any}("Name" => Name, "Processors" => Processors);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel_flow(
Name,
Processors,
channelFlowArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channel-flows/$(channelFlowArn)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Name" => Name, "Processors" => Processors), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel_message(content, channel_arn, message_id, x-amz-chime-bearer)
update_channel_message(content, channel_arn, message_id, x-amz-chime-bearer, params::Dict{String,<:Any})
Updates the content of a message. The x-amz-chime-bearer request header is mandatory. Use
the ARN of the AppInstanceUser or AppInstanceBot that makes the API call as the value in
the header.
# Arguments
- `content`: The content of the channel message.
- `channel_arn`: The ARN of the channel.
- `message_id`: The ID string of the message being updated.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ContentType"`: The content type of the channel message.
- `"Metadata"`: The metadata of the message being updated.
- `"SubChannelId"`: The ID of the SubChannel in the request. Only required when updating
messages in a SubChannel that the user belongs to.
"""
function update_channel_message(
Content,
channelArn,
messageId,
x_amz_chime_bearer;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
"Content" => Content,
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel_message(
Content,
channelArn,
messageId,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/messages/$(messageId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Content" => Content,
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel_read_marker(channel_arn, x-amz-chime-bearer)
update_channel_read_marker(channel_arn, x-amz-chime-bearer, params::Dict{String,<:Any})
The details of the time when a user last read messages in a channel. The
x-amz-chime-bearer request header is mandatory. Use the ARN of the AppInstanceUser or
AppInstanceBot that makes the API call as the value in the header.
# Arguments
- `channel_arn`: The ARN of the channel.
- `x-amz-chime-bearer`: The ARN of the AppInstanceUser or AppInstanceBot that makes the API
call.
"""
function update_channel_read_marker(
channelArn, x_amz_chime_bearer; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/readMarker",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel_read_marker(
channelArn,
x_amz_chime_bearer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_messaging(
"PUT",
"/channels/$(channelArn)/readMarker",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-chime-bearer" => x_amz_chime_bearer),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 118550 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: chime_sdk_voice
using AWS.Compat
using AWS.UUIDs
"""
associate_phone_numbers_with_voice_connector(e164_phone_numbers, voice_connector_id)
associate_phone_numbers_with_voice_connector(e164_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Associates phone numbers with the specified Amazon Chime SDK Voice Connector.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceAssociate"`: If true, associates the provided phone numbers with the provided
Amazon Chime SDK Voice Connector and removes any previously existing associations. If
false, does not associate any phone numbers that have previously existing associations.
"""
function associate_phone_numbers_with_voice_connector(
E164PhoneNumbers, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=associate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_phone_numbers_with_voice_connector(
E164PhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=associate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
associate_phone_numbers_with_voice_connector_group(e164_phone_numbers, voice_connector_group_id)
associate_phone_numbers_with_voice_connector_group(e164_phone_numbers, voice_connector_group_id, params::Dict{String,<:Any})
Associates phone numbers with the specified Amazon Chime SDK Voice Connector group.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_group_id`: The Amazon Chime SDK Voice Connector group ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceAssociate"`: If true, associates the provided phone numbers with the provided
Amazon Chime SDK Voice Connector Group and removes any previously existing associations. If
false, does not associate any phone numbers that have previously existing associations.
"""
function associate_phone_numbers_with_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=associate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_phone_numbers_with_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=associate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_delete_phone_number(phone_number_ids)
batch_delete_phone_number(phone_number_ids, params::Dict{String,<:Any})
Moves phone numbers into the Deletion queue. Phone numbers must be disassociated from any
users or Amazon Chime SDK Voice Connectors before they can be deleted. Phone numbers
remain in the Deletion queue for 7 days before they are deleted permanently.
# Arguments
- `phone_number_ids`: List of phone number IDs.
"""
function batch_delete_phone_number(
PhoneNumberIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/phone-numbers?operation=batch-delete",
Dict{String,Any}("PhoneNumberIds" => PhoneNumberIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_phone_number(
PhoneNumberIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/phone-numbers?operation=batch-delete",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("PhoneNumberIds" => PhoneNumberIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_update_phone_number(update_phone_number_request_items)
batch_update_phone_number(update_phone_number_request_items, params::Dict{String,<:Any})
Updates phone number product types, calling names, or phone number names. You can update
one attribute at a time for each UpdatePhoneNumberRequestItem. For example, you can update
the product type, the calling name, or phone name. You cannot have a duplicate
phoneNumberId in a request.
# Arguments
- `update_phone_number_request_items`: Lists the phone numbers in the update request.
"""
function batch_update_phone_number(
UpdatePhoneNumberRequestItems; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/phone-numbers?operation=batch-update",
Dict{String,Any}("UpdatePhoneNumberRequestItems" => UpdatePhoneNumberRequestItems);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_update_phone_number(
UpdatePhoneNumberRequestItems,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/phone-numbers?operation=batch-update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"UpdatePhoneNumberRequestItems" => UpdatePhoneNumberRequestItems
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_phone_number_order(e164_phone_numbers, product_type)
create_phone_number_order(e164_phone_numbers, product_type, params::Dict{String,<:Any})
Creates an order for phone numbers to be provisioned. For numbers outside the U.S., you
must use the Amazon Chime SDK SIP media application dial-in product type.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `product_type`: The phone number product type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Name"`: Specifies the name assigned to one or more phone numbers.
"""
function create_phone_number_order(
E164PhoneNumbers, ProductType; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/phone-number-orders",
Dict{String,Any}(
"E164PhoneNumbers" => E164PhoneNumbers, "ProductType" => ProductType
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_phone_number_order(
E164PhoneNumbers,
ProductType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/phone-number-orders",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"E164PhoneNumbers" => E164PhoneNumbers, "ProductType" => ProductType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_proxy_session(capabilities, participant_phone_numbers, voice_connector_id)
create_proxy_session(capabilities, participant_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Creates a proxy session for the specified Amazon Chime SDK Voice Connector for the
specified participant phone numbers.
# Arguments
- `capabilities`: The proxy session's capabilities.
- `participant_phone_numbers`: The participant phone numbers.
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpiryMinutes"`: The number of minutes allowed for the proxy session.
- `"GeoMatchLevel"`: The preference for matching the country or area code of the proxy
phone number with that of the first participant.
- `"GeoMatchParams"`: The country and area code for the proxy phone number.
- `"Name"`: The name of the proxy session.
- `"NumberSelectionBehavior"`: The preference for proxy phone number reuse, or stickiness,
between the same participants across sessions.
"""
function create_proxy_session(
Capabilities,
ParticipantPhoneNumbers,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
Dict{String,Any}(
"Capabilities" => Capabilities,
"ParticipantPhoneNumbers" => ParticipantPhoneNumbers,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_proxy_session(
Capabilities,
ParticipantPhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Capabilities" => Capabilities,
"ParticipantPhoneNumbers" => ParticipantPhoneNumbers,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_media_application(aws_region, endpoints, name)
create_sip_media_application(aws_region, endpoints, name, params::Dict{String,<:Any})
Creates a SIP media application. For more information about SIP media applications, see
Managing SIP media applications and rules in the Amazon Chime SDK Administrator Guide.
# Arguments
- `aws_region`: The AWS Region assigned to the SIP media application.
- `endpoints`: List of endpoints (Lambda ARNs) specified for the SIP media application.
- `name`: The SIP media application's name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tags assigned to the SIP media application.
"""
function create_sip_media_application(
AwsRegion, Endpoints, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/sip-media-applications",
Dict{String,Any}(
"AwsRegion" => AwsRegion, "Endpoints" => Endpoints, "Name" => Name
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_media_application(
AwsRegion,
Endpoints,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-media-applications",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AwsRegion" => AwsRegion, "Endpoints" => Endpoints, "Name" => Name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_media_application_call(from_phone_number, to_phone_number, sip_media_application_id)
create_sip_media_application_call(from_phone_number, to_phone_number, sip_media_application_id, params::Dict{String,<:Any})
Creates an outbound call to a phone number from the phone number specified in the request,
and it invokes the endpoint of the specified sipMediaApplicationId.
# Arguments
- `from_phone_number`: The phone number that a user calls from. This is a phone number in
your Amazon Chime SDK phone number inventory.
- `to_phone_number`: The phone number that the service should call.
- `sip_media_application_id`: The ID of the SIP media application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ArgumentsMap"`: Context passed to a CreateSipMediaApplication API call. For example,
you could pass key-value pairs such as: \"FirstName\": \"John\", \"LastName\": \"Doe\"
- `"SipHeaders"`: The SIP headers added to an outbound call leg.
"""
function create_sip_media_application_call(
FromPhoneNumber,
ToPhoneNumber,
sipMediaApplicationId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls",
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber, "ToPhoneNumber" => ToPhoneNumber
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_media_application_call(
FromPhoneNumber,
ToPhoneNumber,
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FromPhoneNumber" => FromPhoneNumber, "ToPhoneNumber" => ToPhoneNumber
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sip_rule(name, trigger_type, trigger_value)
create_sip_rule(name, trigger_type, trigger_value, params::Dict{String,<:Any})
Creates a SIP rule, which can be used to run a SIP media application as a target for a
specific trigger type. For more information about SIP rules, see Managing SIP media
applications and rules in the Amazon Chime SDK Administrator Guide.
# Arguments
- `name`: The name of the SIP rule.
- `trigger_type`: The type of trigger assigned to the SIP rule in TriggerValue, currently
RequestUriHostname or ToPhoneNumber.
- `trigger_value`: If TriggerType is RequestUriHostname, the value can be the outbound host
name of a Voice Connector. If TriggerType is ToPhoneNumber, the value can be a
customer-owned phone number in the E164 format. The SipMediaApplication specified in the
SipRule is triggered if the request URI in an incoming SIP request matches the
RequestUriHostname, or if the To header in the incoming SIP request matches the
ToPhoneNumber value.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: Disables or enables a SIP rule. You must disable SIP rules before you can
delete them.
- `"TargetApplications"`: List of SIP media applications, with priority and AWS Region.
Only one SIP application per AWS Region can be used.
"""
function create_sip_rule(
Name, TriggerType, TriggerValue; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/sip-rules",
Dict{String,Any}(
"Name" => Name, "TriggerType" => TriggerType, "TriggerValue" => TriggerValue
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sip_rule(
Name,
TriggerType,
TriggerValue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-rules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"TriggerType" => TriggerType,
"TriggerValue" => TriggerValue,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_connector(name, require_encryption)
create_voice_connector(name, require_encryption, params::Dict{String,<:Any})
Creates an Amazon Chime SDK Voice Connector. For more information about Voice Connectors,
see Managing Amazon Chime SDK Voice Connector groups in the Amazon Chime SDK Administrator
Guide.
# Arguments
- `name`: The name of the Voice Connector.
- `require_encryption`: Enables or disables encryption for the Voice Connector.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AwsRegion"`: The AWS Region in which the Amazon Chime SDK Voice Connector is created.
Default value: us-east-1 .
- `"Tags"`: The tags assigned to the Voice Connector.
"""
function create_voice_connector(
Name, RequireEncryption; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors",
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_connector(
Name,
RequireEncryption,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_connector_group(name)
create_voice_connector_group(name, params::Dict{String,<:Any})
Creates an Amazon Chime SDK Voice Connector group under the administrator's AWS account.
You can associate Amazon Chime SDK Voice Connectors with the Voice Connector group by
including VoiceConnectorItems in the request. You can include Voice Connectors from
different AWS Regions in your group. This creates a fault tolerant mechanism for fallback
in case of availability events.
# Arguments
- `name`: The name of the Voice Connector group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VoiceConnectorItems"`: Lists the Voice Connectors that inbound calls are routed to.
"""
function create_voice_connector_group(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_connector_group(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_profile(speaker_search_task_id)
create_voice_profile(speaker_search_task_id, params::Dict{String,<:Any})
Creates a voice profile, which consists of an enrolled user and their latest voice print.
Before creating any voice profiles, you must provide all notices and obtain all consents
from the speaker as required under applicable privacy and biometrics laws, and as required
under the AWS service terms for the Amazon Chime SDK. For more information about voice
profiles and voice analytics, see Using Amazon Chime SDK Voice Analytics in the Amazon
Chime SDK Developer Guide.
# Arguments
- `speaker_search_task_id`: The ID of the speaker search task.
"""
function create_voice_profile(
SpeakerSearchTaskId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-profiles",
Dict{String,Any}("SpeakerSearchTaskId" => SpeakerSearchTaskId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_profile(
SpeakerSearchTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-profiles",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("SpeakerSearchTaskId" => SpeakerSearchTaskId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_voice_profile_domain(name, server_side_encryption_configuration)
create_voice_profile_domain(name, server_side_encryption_configuration, params::Dict{String,<:Any})
Creates a voice profile domain, a collection of voice profiles, their voice prints, and
encrypted enrollment audio. Before creating any voice profiles, you must provide all
notices and obtain all consents from the speaker as required under applicable privacy and
biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK. For
more information about voice profile domains, see Using Amazon Chime SDK Voice Analytics in
the Amazon Chime SDK Developer Guide.
# Arguments
- `name`: The name of the voice profile domain.
- `server_side_encryption_configuration`: The server-side encryption configuration for the
request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the client request. Use a different
token for different domain creation requests.
- `"Description"`: A description of the voice profile domain.
- `"Tags"`: The tags assigned to the domain.
"""
function create_voice_profile_domain(
Name,
ServerSideEncryptionConfiguration;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-profile-domains",
Dict{String,Any}(
"Name" => Name,
"ServerSideEncryptionConfiguration" => ServerSideEncryptionConfiguration,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_voice_profile_domain(
Name,
ServerSideEncryptionConfiguration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-profile-domains",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"ServerSideEncryptionConfiguration" =>
ServerSideEncryptionConfiguration,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_phone_number(phone_number_id)
delete_phone_number(phone_number_id, params::Dict{String,<:Any})
Moves the specified phone number into the Deletion queue. A phone number must be
disassociated from any users or Amazon Chime SDK Voice Connectors before it can be deleted.
Deleted phone numbers remain in the Deletion queue queue for 7 days before they are deleted
permanently.
# Arguments
- `phone_number_id`: The phone number ID.
"""
function delete_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_proxy_session(proxy_session_id, voice_connector_id)
delete_proxy_session(proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Deletes the specified proxy session from the specified Amazon Chime SDK Voice Connector.
# Arguments
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_proxy_session(
proxySessionId, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_proxy_session(
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_sip_media_application(sip_media_application_id)
delete_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Deletes a SIP media application.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function delete_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_sip_rule(sip_rule_id)
delete_sip_rule(sip_rule_id, params::Dict{String,<:Any})
Deletes a SIP rule.
# Arguments
- `sip_rule_id`: The SIP rule ID.
"""
function delete_sip_rule(sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"DELETE",
"/sip-rules/$(sipRuleId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_sip_rule(
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/sip-rules/$(sipRuleId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector(voice_connector_id)
delete_voice_connector(voice_connector_id, params::Dict{String,<:Any})
Deletes an Amazon Chime SDK Voice Connector. Any phone numbers associated with the Amazon
Chime SDK Voice Connector must be disassociated from it before it can be deleted.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_emergency_calling_configuration(voice_connector_id)
delete_voice_connector_emergency_calling_configuration(voice_connector_id, params::Dict{String,<:Any})
Deletes the emergency calling details from the specified Amazon Chime SDK Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_emergency_calling_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_emergency_calling_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_group(voice_connector_group_id)
delete_voice_connector_group(voice_connector_group_id, params::Dict{String,<:Any})
Deletes an Amazon Chime SDK Voice Connector group. Any VoiceConnectorItems and phone
numbers associated with the group must be removed before it can be deleted.
# Arguments
- `voice_connector_group_id`: The Voice Connector Group ID.
"""
function delete_voice_connector_group(
voiceConnectorGroupId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connector-groups/$(voiceConnectorGroupId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_group(
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connector-groups/$(voiceConnectorGroupId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_origination(voice_connector_id)
delete_voice_connector_origination(voice_connector_id, params::Dict{String,<:Any})
Deletes the origination settings for the specified Amazon Chime SDK Voice Connector. If
emergency calling is configured for the Voice Connector, it must be deleted prior to
deleting the origination settings.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_origination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/origination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_origination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/origination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_proxy(voice_connector_id)
delete_voice_connector_proxy(voice_connector_id, params::Dict{String,<:Any})
Deletes the proxy configuration from the specified Amazon Chime SDK Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_proxy(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_proxy(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_streaming_configuration(voice_connector_id)
delete_voice_connector_streaming_configuration(voice_connector_id, params::Dict{String,<:Any})
Deletes a Voice Connector's streaming configuration.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_streaming_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_streaming_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_termination(voice_connector_id)
delete_voice_connector_termination(voice_connector_id, params::Dict{String,<:Any})
Deletes the termination settings for the specified Amazon Chime SDK Voice Connector. If
emergency calling is configured for the Voice Connector, it must be deleted prior to
deleting the termination settings.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_termination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/termination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_termination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-connectors/$(voiceConnectorId)/termination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_connector_termination_credentials(usernames, voice_connector_id)
delete_voice_connector_termination_credentials(usernames, voice_connector_id, params::Dict{String,<:Any})
Deletes the specified SIP credentials used by your equipment to authenticate during call
termination.
# Arguments
- `usernames`: The RFC2617 compliant username associated with the SIP credentials, in
US-ASCII format.
- `voice_connector_id`: The Voice Connector ID.
"""
function delete_voice_connector_termination_credentials(
Usernames, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=delete",
Dict{String,Any}("Usernames" => Usernames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_connector_termination_credentials(
Usernames,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=delete",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Usernames" => Usernames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_profile(voice_profile_id)
delete_voice_profile(voice_profile_id, params::Dict{String,<:Any})
Deletes a voice profile, including its voice print and enrollment data. WARNING: This
action is not reversible.
# Arguments
- `voice_profile_id`: The voice profile ID.
"""
function delete_voice_profile(
VoiceProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-profiles/$(VoiceProfileId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_profile(
VoiceProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-profiles/$(VoiceProfileId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_voice_profile_domain(voice_profile_domain_id)
delete_voice_profile_domain(voice_profile_domain_id, params::Dict{String,<:Any})
Deletes all voice profiles in the domain. WARNING: This action is not reversible.
# Arguments
- `voice_profile_domain_id`: The voice profile domain ID.
"""
function delete_voice_profile_domain(
VoiceProfileDomainId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"DELETE",
"/voice-profile-domains/$(VoiceProfileDomainId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_voice_profile_domain(
VoiceProfileDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"DELETE",
"/voice-profile-domains/$(VoiceProfileDomainId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_phone_numbers_from_voice_connector(e164_phone_numbers, voice_connector_id)
disassociate_phone_numbers_from_voice_connector(e164_phone_numbers, voice_connector_id, params::Dict{String,<:Any})
Disassociates the specified phone numbers from the specified Amazon Chime SDK Voice
Connector.
# Arguments
- `e164_phone_numbers`: List of phone numbers, in E.164 format.
- `voice_connector_id`: The Voice Connector ID.
"""
function disassociate_phone_numbers_from_voice_connector(
E164PhoneNumbers, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=disassociate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_phone_numbers_from_voice_connector(
E164PhoneNumbers,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)?operation=disassociate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_phone_numbers_from_voice_connector_group(e164_phone_numbers, voice_connector_group_id)
disassociate_phone_numbers_from_voice_connector_group(e164_phone_numbers, voice_connector_group_id, params::Dict{String,<:Any})
Disassociates the specified phone numbers from the specified Amazon Chime SDK Voice
Connector group.
# Arguments
- `e164_phone_numbers`: The list of phone numbers, in E.164 format.
- `voice_connector_group_id`: The Voice Connector group ID.
"""
function disassociate_phone_numbers_from_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=disassociate-phone-numbers",
Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_phone_numbers_from_voice_connector_group(
E164PhoneNumbers,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connector-groups/$(voiceConnectorGroupId)?operation=disassociate-phone-numbers",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("E164PhoneNumbers" => E164PhoneNumbers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_global_settings()
get_global_settings(params::Dict{String,<:Any})
Retrieves the global settings for the Amazon Chime SDK Voice Connectors in an AWS account.
"""
function get_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET", "/settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET", "/settings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_phone_number(phone_number_id)
get_phone_number(phone_number_id, params::Dict{String,<:Any})
Retrieves details for the specified phone number ID, such as associations, capabilities,
and product type.
# Arguments
- `phone_number_id`: The phone number ID.
"""
function get_phone_number(phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_phone_number_order(phone_number_order_id)
get_phone_number_order(phone_number_order_id, params::Dict{String,<:Any})
Retrieves details for the specified phone number order, such as the order creation
timestamp, phone numbers in E.164 format, product type, and order status.
# Arguments
- `phone_number_order_id`: The ID of the phone number order .
"""
function get_phone_number_order(
phoneNumberOrderId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/phone-number-orders/$(phoneNumberOrderId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number_order(
phoneNumberOrderId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/phone-number-orders/$(phoneNumberOrderId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_phone_number_settings()
get_phone_number_settings(params::Dict{String,<:Any})
Retrieves the phone number settings for the administrator's AWS account, such as the
default outbound calling name.
"""
function get_phone_number_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/settings/phone-number";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_phone_number_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/settings/phone-number",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_proxy_session(proxy_session_id, voice_connector_id)
get_proxy_session(proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Retrieves the specified proxy session details for the specified Amazon Chime SDK Voice
Connector.
# Arguments
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Voice Connector ID.
"""
function get_proxy_session(
proxySessionId, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_proxy_session(
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_media_application(sip_media_application_id)
get_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Retrieves the information for a SIP media application, including name, AWS Region, and
endpoints.
# Arguments
- `sip_media_application_id`: The SIP media application ID .
"""
function get_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_media_application_alexa_skill_configuration(sip_media_application_id)
get_sip_media_application_alexa_skill_configuration(sip_media_application_id, params::Dict{String,<:Any})
Gets the Alexa Skill configuration for the SIP media application. Due to changes made by
the Amazon Alexa service, this API is no longer available for use. For more information,
refer to the Alexa Smart Properties page.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function get_sip_media_application_alexa_skill_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/alexa-skill-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_media_application_alexa_skill_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/alexa-skill-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_media_application_logging_configuration(sip_media_application_id)
get_sip_media_application_logging_configuration(sip_media_application_id, params::Dict{String,<:Any})
Retrieves the logging configuration for the specified SIP media application.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
"""
function get_sip_media_application_logging_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_media_application_logging_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sip_rule(sip_rule_id)
get_sip_rule(sip_rule_id, params::Dict{String,<:Any})
Retrieves the details of a SIP rule, such as the rule ID, name, triggers, and target
endpoints.
# Arguments
- `sip_rule_id`: The SIP rule ID.
"""
function get_sip_rule(sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/sip-rules/$(sipRuleId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sip_rule(
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/sip-rules/$(sipRuleId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_speaker_search_task(speaker_search_task_id, voice_connector_id)
get_speaker_search_task(speaker_search_task_id, voice_connector_id, params::Dict{String,<:Any})
Retrieves the details of the specified speaker search task.
# Arguments
- `speaker_search_task_id`: The ID of the speaker search task.
- `voice_connector_id`: The Voice Connector ID.
"""
function get_speaker_search_task(
SpeakerSearchTaskId, VoiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks/$(SpeakerSearchTaskId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_speaker_search_task(
SpeakerSearchTaskId,
VoiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks/$(SpeakerSearchTaskId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector(voice_connector_id)
get_voice_connector(voice_connector_id, params::Dict{String,<:Any})
Retrieves details for the specified Amazon Chime SDK Voice Connector, such as
timestamps,name, outbound host, and encryption requirements.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_emergency_calling_configuration(voice_connector_id)
get_voice_connector_emergency_calling_configuration(voice_connector_id, params::Dict{String,<:Any})
Retrieves the emergency calling configuration details for the specified Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_emergency_calling_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_emergency_calling_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_group(voice_connector_group_id)
get_voice_connector_group(voice_connector_group_id, params::Dict{String,<:Any})
Retrieves details for the specified Amazon Chime SDK Voice Connector group, such as
timestamps,name, and associated VoiceConnectorItems.
# Arguments
- `voice_connector_group_id`: The Voice Connector group ID.
"""
function get_voice_connector_group(
voiceConnectorGroupId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connector-groups/$(voiceConnectorGroupId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_group(
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connector-groups/$(voiceConnectorGroupId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_logging_configuration(voice_connector_id)
get_voice_connector_logging_configuration(voice_connector_id, params::Dict{String,<:Any})
Retrieves the logging configuration settings for the specified Voice Connector. Shows
whether SIP message logs are enabled for sending to Amazon CloudWatch Logs.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_logging_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_logging_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_origination(voice_connector_id)
get_voice_connector_origination(voice_connector_id, params::Dict{String,<:Any})
Retrieves the origination settings for the specified Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_origination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/origination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_origination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/origination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_proxy(voice_connector_id)
get_voice_connector_proxy(voice_connector_id, params::Dict{String,<:Any})
Retrieves the proxy configuration details for the specified Amazon Chime SDK Voice
Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_proxy(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_proxy(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_streaming_configuration(voice_connector_id)
get_voice_connector_streaming_configuration(voice_connector_id, params::Dict{String,<:Any})
Retrieves the streaming configuration details for the specified Amazon Chime SDK Voice
Connector. Shows whether media streaming is enabled for sending to Amazon Kinesis. It also
shows the retention period, in hours, for the Amazon Kinesis data.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_streaming_configuration(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_streaming_configuration(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_termination(voice_connector_id)
get_voice_connector_termination(voice_connector_id, params::Dict{String,<:Any})
Retrieves the termination setting details for the specified Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_termination(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_termination(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_connector_termination_health(voice_connector_id)
get_voice_connector_termination_health(voice_connector_id, params::Dict{String,<:Any})
Retrieves information about the last time a SIP OPTIONS ping was received from your SIP
infrastructure for the specified Amazon Chime SDK Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function get_voice_connector_termination_health(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/health";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_connector_termination_health(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/health",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_profile(voice_profile_id)
get_voice_profile(voice_profile_id, params::Dict{String,<:Any})
Retrieves the details of the specified voice profile.
# Arguments
- `voice_profile_id`: The voice profile ID.
"""
function get_voice_profile(
VoiceProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-profiles/$(VoiceProfileId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_profile(
VoiceProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-profiles/$(VoiceProfileId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_profile_domain(voice_profile_domain_id)
get_voice_profile_domain(voice_profile_domain_id, params::Dict{String,<:Any})
Retrieves the details of the specified voice profile domain.
# Arguments
- `voice_profile_domain_id`: The voice profile domain ID.
"""
function get_voice_profile_domain(
VoiceProfileDomainId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-profile-domains/$(VoiceProfileDomainId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_profile_domain(
VoiceProfileDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-profile-domains/$(VoiceProfileDomainId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_voice_tone_analysis_task(voice_connector_id, voice_tone_analysis_task_id, is_caller)
get_voice_tone_analysis_task(voice_connector_id, voice_tone_analysis_task_id, is_caller, params::Dict{String,<:Any})
Retrieves the details of a voice tone analysis task.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
- `voice_tone_analysis_task_id`: The ID of the voice tone anlysis task.
- `is_caller`: Specifies whether the voice being analyzed is the caller (originator) or the
callee (responder).
"""
function get_voice_tone_analysis_task(
VoiceConnectorId,
VoiceToneAnalysisTaskId,
isCaller;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks/$(VoiceToneAnalysisTaskId)",
Dict{String,Any}("isCaller" => isCaller);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_voice_tone_analysis_task(
VoiceConnectorId,
VoiceToneAnalysisTaskId,
isCaller,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks/$(VoiceToneAnalysisTaskId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("isCaller" => isCaller), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_available_voice_connector_regions()
list_available_voice_connector_regions(params::Dict{String,<:Any})
Lists the available AWS Regions in which you can create an Amazon Chime SDK Voice Connector.
"""
function list_available_voice_connector_regions(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connector-regions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_available_voice_connector_regions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connector-regions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_phone_number_orders()
list_phone_number_orders(params::Dict{String,<:Any})
Lists the phone numbers for an administrator's Amazon Chime SDK account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to retrieve the next page of results.
"""
function list_phone_number_orders(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/phone-number-orders";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_phone_number_orders(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/phone-number-orders",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_phone_numbers()
list_phone_numbers(params::Dict{String,<:Any})
Lists the phone numbers for the specified Amazon Chime SDK account, Amazon Chime SDK user,
Amazon Chime SDK Voice Connector, or Amazon Chime SDK Voice Connector group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter-name"`: The filter to limit the number of results.
- `"filter-value"`: The filter value.
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
- `"product-type"`: The phone number product types.
- `"status"`: The status of your organization's phone numbers.
"""
function list_phone_numbers(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET", "/phone-numbers"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_phone_numbers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/phone-numbers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_proxy_sessions(voice_connector_id)
list_proxy_sessions(voice_connector_id, params::Dict{String,<:Any})
Lists the proxy sessions for the specified Amazon Chime SDK Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to retrieve the next page of results.
- `"status"`: The proxy session status.
"""
function list_proxy_sessions(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_proxy_sessions(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sip_media_applications()
list_sip_media_applications(params::Dict{String,<:Any})
Lists the SIP media applications under the administrator's AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"next-token"`: The token used to return the next page of results.
"""
function list_sip_media_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/sip-media-applications";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sip_media_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/sip-media-applications",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sip_rules()
list_sip_rules(params::Dict{String,<:Any})
Lists the SIP rules under the administrator's AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call. Defaults to
100.
- `"next-token"`: The token used to return the next page of results.
- `"sip-media-application"`: The SIP media application ID.
"""
function list_sip_rules(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET", "/sip-rules"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_sip_rules(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET", "/sip-rules", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_supported_phone_number_countries(product-type)
list_supported_phone_number_countries(product-type, params::Dict{String,<:Any})
Lists the countries that you can order phone numbers from.
# Arguments
- `product-type`: The phone number product type.
"""
function list_supported_phone_number_countries(
product_type; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/phone-number-countries",
Dict{String,Any}("product-type" => product_type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_supported_phone_number_countries(
product_type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/phone-number-countries",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("product-type" => product_type), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(arn)
list_tags_for_resource(arn, params::Dict{String,<:Any})
Returns a list of the tags in a given resource.
# Arguments
- `arn`: The resource ARN.
"""
function list_tags_for_resource(arn; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/tags",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/tags",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connector_groups()
list_voice_connector_groups(params::Dict{String,<:Any})
Lists the Amazon Chime SDK Voice Connector groups in the administrator's AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
"""
function list_voice_connector_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/voice-connector-groups";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_connector_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connector-groups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connector_termination_credentials(voice_connector_id)
list_voice_connector_termination_credentials(voice_connector_id, params::Dict{String,<:Any})
Lists the SIP credentials for the specified Amazon Chime SDK Voice Connector.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
"""
function list_voice_connector_termination_credentials(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/credentials";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_connector_termination_credentials(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-connectors/$(voiceConnectorId)/termination/credentials",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_connectors()
list_voice_connectors(params::Dict{String,<:Any})
Lists the Amazon Chime SDK Voice Connectors in the administrators AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
"""
function list_voice_connectors(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET", "/voice-connectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_voice_connectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-connectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_profile_domains()
list_voice_profile_domains(params::Dict{String,<:Any})
Lists the specified voice profile domains in the administrator's AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return in a single call.
- `"next-token"`: The token used to return the next page of results.
"""
function list_voice_profile_domains(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/voice-profile-domains";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_profile_domains(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-profile-domains",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_voice_profiles(voice-profile-domain-id)
list_voice_profiles(voice-profile-domain-id, params::Dict{String,<:Any})
Lists the voice profiles in a voice profile domain.
# Arguments
- `voice-profile-domain-id`: The ID of the voice profile domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results in the request.
- `"next-token"`: The token used to retrieve the next page of results.
"""
function list_voice_profiles(
voice_profile_domain_id; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/voice-profiles",
Dict{String,Any}("voice-profile-domain-id" => voice_profile_domain_id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_voice_profiles(
voice_profile_domain_id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"GET",
"/voice-profiles",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("voice-profile-domain-id" => voice_profile_domain_id),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_sip_media_application_alexa_skill_configuration(sip_media_application_id)
put_sip_media_application_alexa_skill_configuration(sip_media_application_id, params::Dict{String,<:Any})
Updates the Alexa Skill configuration for the SIP media application. Due to changes made
by the Amazon Alexa service, this API is no longer available for use. For more information,
refer to the Alexa Smart Properties page.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SipMediaApplicationAlexaSkillConfiguration"`: The Alexa Skill configuration.
"""
function put_sip_media_application_alexa_skill_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/alexa-skill-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_sip_media_application_alexa_skill_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/alexa-skill-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_sip_media_application_logging_configuration(sip_media_application_id)
put_sip_media_application_logging_configuration(sip_media_application_id, params::Dict{String,<:Any})
Updates the logging configuration for the specified SIP media application.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SipMediaApplicationLoggingConfiguration"`: The logging configuration for the specified
SIP media application.
"""
function put_sip_media_application_logging_configuration(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_sip_media_application_logging_configuration(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)/logging-configuration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_emergency_calling_configuration(emergency_calling_configuration, voice_connector_id)
put_voice_connector_emergency_calling_configuration(emergency_calling_configuration, voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's emergency calling configuration.
# Arguments
- `emergency_calling_configuration`: The configuration being updated.
- `voice_connector_id`: The Voice Connector ID.
"""
function put_voice_connector_emergency_calling_configuration(
EmergencyCallingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
Dict{String,Any}("EmergencyCallingConfiguration" => EmergencyCallingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_emergency_calling_configuration(
EmergencyCallingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/emergency-calling-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EmergencyCallingConfiguration" => EmergencyCallingConfiguration
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_logging_configuration(logging_configuration, voice_connector_id)
put_voice_connector_logging_configuration(logging_configuration, voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's logging configuration.
# Arguments
- `logging_configuration`: The logging configuration being updated.
- `voice_connector_id`: The Voice Connector ID.
"""
function put_voice_connector_logging_configuration(
LoggingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
Dict{String,Any}("LoggingConfiguration" => LoggingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_logging_configuration(
LoggingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/logging-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("LoggingConfiguration" => LoggingConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_origination(origination, voice_connector_id)
put_voice_connector_origination(origination, voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's origination settings.
# Arguments
- `origination`: The origination settings being updated.
- `voice_connector_id`: The Voice Connector ID.
"""
function put_voice_connector_origination(
Origination, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/origination",
Dict{String,Any}("Origination" => Origination);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_origination(
Origination,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/origination",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Origination" => Origination), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_proxy(default_session_expiry_minutes, phone_number_pool_countries, voice_connector_id)
put_voice_connector_proxy(default_session_expiry_minutes, phone_number_pool_countries, voice_connector_id, params::Dict{String,<:Any})
Puts the specified proxy configuration to the specified Amazon Chime SDK Voice Connector.
# Arguments
- `default_session_expiry_minutes`: The default number of minutes allowed for proxy session.
- `phone_number_pool_countries`: The countries for proxy phone numbers to be selected from.
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: When true, stops proxy sessions from being created on the specified Amazon
Chime SDK Voice Connector.
- `"FallBackPhoneNumber"`: The phone number to route calls to after a proxy session expires.
"""
function put_voice_connector_proxy(
DefaultSessionExpiryMinutes,
PhoneNumberPoolCountries,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
Dict{String,Any}(
"DefaultSessionExpiryMinutes" => DefaultSessionExpiryMinutes,
"PhoneNumberPoolCountries" => PhoneNumberPoolCountries,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_proxy(
DefaultSessionExpiryMinutes,
PhoneNumberPoolCountries,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/programmable-numbers/proxy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DefaultSessionExpiryMinutes" => DefaultSessionExpiryMinutes,
"PhoneNumberPoolCountries" => PhoneNumberPoolCountries,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_streaming_configuration(streaming_configuration, voice_connector_id)
put_voice_connector_streaming_configuration(streaming_configuration, voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's streaming configuration settings.
# Arguments
- `streaming_configuration`: The streaming settings being updated.
- `voice_connector_id`: The Voice Connector ID.
"""
function put_voice_connector_streaming_configuration(
StreamingConfiguration,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
Dict{String,Any}("StreamingConfiguration" => StreamingConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_streaming_configuration(
StreamingConfiguration,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/streaming-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("StreamingConfiguration" => StreamingConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_termination(termination, voice_connector_id)
put_voice_connector_termination(termination, voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's termination settings.
# Arguments
- `termination`: The termination settings to be updated.
- `voice_connector_id`: The Voice Connector ID.
"""
function put_voice_connector_termination(
Termination, voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/termination",
Dict{String,Any}("Termination" => Termination);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_termination(
Termination,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)/termination",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Termination" => Termination), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_voice_connector_termination_credentials(voice_connector_id)
put_voice_connector_termination_credentials(voice_connector_id, params::Dict{String,<:Any})
Updates a Voice Connector's termination credentials.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Credentials"`: The termination credentials being updated.
"""
function put_voice_connector_termination_credentials(
voiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=put";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_voice_connector_termination_credentials(
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/termination/credentials?operation=put",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
restore_phone_number(phone_number_id)
restore_phone_number(phone_number_id, params::Dict{String,<:Any})
Restores a deleted phone number.
# Arguments
- `phone_number_id`: The ID of the phone number being restored.
"""
function restore_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/phone-numbers/$(phoneNumberId)?operation=restore";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function restore_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/phone-numbers/$(phoneNumberId)?operation=restore",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
search_available_phone_numbers()
search_available_phone_numbers(params::Dict{String,<:Any})
Searches the provisioned phone numbers in an organization.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"area-code"`: Confines a search to just the phone numbers associated with the specified
area code.
- `"city"`: Confines a search to just the phone numbers associated with the specified city.
- `"country"`: Confines a search to just the phone numbers associated with the specified
country.
- `"max-results"`: The maximum number of results to return.
- `"next-token"`: The token used to return the next page of results.
- `"phone-number-type"`: Confines a search to just the phone numbers associated with the
specified phone number type, either local or toll-free.
- `"state"`: Confines a search to just the phone numbers associated with the specified
state.
- `"toll-free-prefix"`: Confines a search to just the phone numbers associated with the
specified toll-free prefix.
"""
function search_available_phone_numbers(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"GET",
"/search?type=phone-numbers";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search_available_phone_numbers(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"GET",
"/search?type=phone-numbers",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_speaker_search_task(transaction_id, voice_connector_id, voice_profile_domain_id)
start_speaker_search_task(transaction_id, voice_connector_id, voice_profile_domain_id, params::Dict{String,<:Any})
Starts a speaker search task. Before starting any speaker search tasks, you must provide
all notices and obtain all consents from the speaker as required under applicable privacy
and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
# Arguments
- `transaction_id`: The transaction ID of the call being analyzed.
- `voice_connector_id`: The Voice Connector ID.
- `voice_profile_domain_id`: The ID of the voice profile domain that will store the voice
profile.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallLeg"`: Specifies which call leg to stream for speaker search.
- `"ClientRequestToken"`: The unique identifier for the client request. Use a different
token for different speaker search tasks.
"""
function start_speaker_search_task(
TransactionId,
VoiceConnectorId,
VoiceProfileDomainId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks",
Dict{String,Any}(
"TransactionId" => TransactionId, "VoiceProfileDomainId" => VoiceProfileDomainId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_speaker_search_task(
TransactionId,
VoiceConnectorId,
VoiceProfileDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TransactionId" => TransactionId,
"VoiceProfileDomainId" => VoiceProfileDomainId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_voice_tone_analysis_task(language_code, transaction_id, voice_connector_id)
start_voice_tone_analysis_task(language_code, transaction_id, voice_connector_id, params::Dict{String,<:Any})
Starts a voice tone analysis task. For more information about voice tone analysis, see
Using Amazon Chime SDK voice analytics in the Amazon Chime SDK Developer Guide. Before
starting any voice tone analysis tasks, you must provide all notices and obtain all
consents from the speaker as required under applicable privacy and biometrics laws, and as
required under the AWS service terms for the Amazon Chime SDK.
# Arguments
- `language_code`: The language code.
- `transaction_id`: The transaction ID.
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: The unique identifier for the client request. Use a different
token for different voice tone analysis tasks.
"""
function start_voice_tone_analysis_task(
LanguageCode,
TransactionId,
VoiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks",
Dict{String,Any}("LanguageCode" => LanguageCode, "TransactionId" => TransactionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_voice_tone_analysis_task(
LanguageCode,
TransactionId,
VoiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LanguageCode" => LanguageCode, "TransactionId" => TransactionId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_speaker_search_task(speaker_search_task_id, voice_connector_id)
stop_speaker_search_task(speaker_search_task_id, voice_connector_id, params::Dict{String,<:Any})
Stops a speaker search task.
# Arguments
- `speaker_search_task_id`: The speaker search task ID.
- `voice_connector_id`: The Voice Connector ID.
"""
function stop_speaker_search_task(
SpeakerSearchTaskId, VoiceConnectorId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks/$(SpeakerSearchTaskId)?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_speaker_search_task(
SpeakerSearchTaskId,
VoiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/speaker-search-tasks/$(SpeakerSearchTaskId)?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_voice_tone_analysis_task(voice_connector_id, voice_tone_analysis_task_id)
stop_voice_tone_analysis_task(voice_connector_id, voice_tone_analysis_task_id, params::Dict{String,<:Any})
Stops a voice tone analysis task.
# Arguments
- `voice_connector_id`: The Voice Connector ID.
- `voice_tone_analysis_task_id`: The ID of the voice tone analysis task.
"""
function stop_voice_tone_analysis_task(
VoiceConnectorId,
VoiceToneAnalysisTaskId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks/$(VoiceToneAnalysisTaskId)?operation=stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_voice_tone_analysis_task(
VoiceConnectorId,
VoiceToneAnalysisTaskId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(VoiceConnectorId)/voice-tone-analysis-tasks/$(VoiceToneAnalysisTaskId)?operation=stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds a tag to the specified resource.
# Arguments
- `resource_arn`: The ARN of the resource being tagged.
- `tags`: A list of the tags being added to the resource.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/tags?operation=tag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from a resource.
# Arguments
- `resource_arn`: The ARN of the resource having its tags removed.
- `tag_keys`: The keys of the tags being removed from the resource.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/tags?operation=untag-resource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_global_settings()
update_global_settings(params::Dict{String,<:Any})
Updates global settings for the Amazon Chime SDK Voice Connectors in an AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VoiceConnector"`: The Voice Connector settings.
"""
function update_global_settings(; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"PUT", "/settings"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_global_settings(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT", "/settings", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_phone_number(phone_number_id)
update_phone_number(phone_number_id, params::Dict{String,<:Any})
Updates phone number details, such as product type, calling name, or phone number name for
the specified phone number ID. You can update one phone number detail at a time. For
example, you can update either the product type, calling name, or phone number name in one
action. For numbers outside the U.S., you must use the Amazon Chime SDK SIP Media
Application Dial-In product type. Updates to outbound calling names can take 72 hours to
complete. Pending updates to outbound calling names must be complete before you can request
another update.
# Arguments
- `phone_number_id`: The phone number ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallingName"`: The outbound calling name associated with the phone number.
- `"Name"`: Specifies the updated name assigned to one or more phone numbers.
- `"ProductType"`: The product type.
"""
function update_phone_number(
phoneNumberId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"POST",
"/phone-numbers/$(phoneNumberId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_phone_number(
phoneNumberId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/phone-numbers/$(phoneNumberId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_phone_number_settings(calling_name)
update_phone_number_settings(calling_name, params::Dict{String,<:Any})
Updates the phone number settings for the administrator's AWS account, such as the default
outbound calling name. You can update the default outbound calling name once every seven
days. Outbound calling names can take up to 72 hours to update.
# Arguments
- `calling_name`: The default outbound calling name for the account.
"""
function update_phone_number_settings(
CallingName; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/settings/phone-number",
Dict{String,Any}("CallingName" => CallingName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_phone_number_settings(
CallingName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/settings/phone-number",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("CallingName" => CallingName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_proxy_session(capabilities, proxy_session_id, voice_connector_id)
update_proxy_session(capabilities, proxy_session_id, voice_connector_id, params::Dict{String,<:Any})
Updates the specified proxy session details, such as voice or SMS capabilities.
# Arguments
- `capabilities`: The proxy session capabilities.
- `proxy_session_id`: The proxy session ID.
- `voice_connector_id`: The Voice Connector ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExpiryMinutes"`: The number of minutes allowed for the proxy session.
"""
function update_proxy_session(
Capabilities,
proxySessionId,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
Dict{String,Any}("Capabilities" => Capabilities);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_proxy_session(
Capabilities,
proxySessionId,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/voice-connectors/$(voiceConnectorId)/proxy-sessions/$(proxySessionId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Capabilities" => Capabilities), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_media_application(sip_media_application_id)
update_sip_media_application(sip_media_application_id, params::Dict{String,<:Any})
Updates the details of the specified SIP media application.
# Arguments
- `sip_media_application_id`: The SIP media application ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Endpoints"`: The new set of endpoints for the specified SIP media application.
- `"Name"`: The new name for the specified SIP media application.
"""
function update_sip_media_application(
sipMediaApplicationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_media_application(
sipMediaApplicationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/sip-media-applications/$(sipMediaApplicationId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_media_application_call(arguments, sip_media_application_id, transaction_id)
update_sip_media_application_call(arguments, sip_media_application_id, transaction_id, params::Dict{String,<:Any})
Invokes the AWS Lambda function associated with the SIP media application and transaction
ID in an update request. The Lambda function can then return a new set of actions.
# Arguments
- `arguments`: Arguments made available to the Lambda function as part of the
CALL_UPDATE_REQUESTED event. Can contain 0-20 key-value pairs.
- `sip_media_application_id`: The ID of the SIP media application handling the call.
- `transaction_id`: The ID of the call transaction.
"""
function update_sip_media_application_call(
Arguments,
sipMediaApplicationId,
transactionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls/$(transactionId)",
Dict{String,Any}("Arguments" => Arguments);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_media_application_call(
Arguments,
sipMediaApplicationId,
transactionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/sip-media-applications/$(sipMediaApplicationId)/calls/$(transactionId)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Arguments" => Arguments), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sip_rule(name, sip_rule_id)
update_sip_rule(name, sip_rule_id, params::Dict{String,<:Any})
Updates the details of the specified SIP rule.
# Arguments
- `name`: The new name for the specified SIP rule.
- `sip_rule_id`: The SIP rule ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Disabled"`: The new value that indicates whether the rule is disabled.
- `"TargetApplications"`: The new list of target applications.
"""
function update_sip_rule(Name, sipRuleId; aws_config::AbstractAWSConfig=global_aws_config())
return chime_sdk_voice(
"PUT",
"/sip-rules/$(sipRuleId)",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sip_rule(
Name,
sipRuleId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/sip-rules/$(sipRuleId)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_connector(name, require_encryption, voice_connector_id)
update_voice_connector(name, require_encryption, voice_connector_id, params::Dict{String,<:Any})
Updates the details for the specified Amazon Chime SDK Voice Connector.
# Arguments
- `name`: The name of the Voice Connector.
- `require_encryption`: When enabled, requires encryption for the Voice Connector.
- `voice_connector_id`: The Voice Connector ID.
"""
function update_voice_connector(
Name,
RequireEncryption,
voiceConnectorId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)",
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_connector(
Name,
RequireEncryption,
voiceConnectorId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connectors/$(voiceConnectorId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "RequireEncryption" => RequireEncryption),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_connector_group(name, voice_connector_items, voice_connector_group_id)
update_voice_connector_group(name, voice_connector_items, voice_connector_group_id, params::Dict{String,<:Any})
Updates the settings for the specified Amazon Chime SDK Voice Connector group.
# Arguments
- `name`: The name of the Voice Connector group.
- `voice_connector_items`: The VoiceConnectorItems to associate with the Voice Connector
group.
- `voice_connector_group_id`: The Voice Connector ID.
"""
function update_voice_connector_group(
Name,
VoiceConnectorItems,
voiceConnectorGroupId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connector-groups/$(voiceConnectorGroupId)",
Dict{String,Any}("Name" => Name, "VoiceConnectorItems" => VoiceConnectorItems);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_connector_group(
Name,
VoiceConnectorItems,
voiceConnectorGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-connector-groups/$(voiceConnectorGroupId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name, "VoiceConnectorItems" => VoiceConnectorItems
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_profile(speaker_search_task_id, voice_profile_id)
update_voice_profile(speaker_search_task_id, voice_profile_id, params::Dict{String,<:Any})
Updates the specified voice profile’s voice print and refreshes its expiration timestamp.
As a condition of using this feature, you acknowledge that the collection, use, storage,
and retention of your caller’s biometric identifiers and biometric information
(“biometric data”) in the form of a digital voiceprint requires the caller’s informed
consent via a written release. Such consent is required under various state laws, including
biometrics laws in Illinois, Texas, Washington and other state privacy laws. You must
provide a written release to each caller through a process that clearly reflects each
caller’s informed consent before using Amazon Chime SDK Voice Insights service, as
required under the terms of your agreement with AWS governing your use of the service.
# Arguments
- `speaker_search_task_id`: The ID of the speaker search task.
- `voice_profile_id`: The profile ID.
"""
function update_voice_profile(
SpeakerSearchTaskId, VoiceProfileId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/voice-profiles/$(VoiceProfileId)",
Dict{String,Any}("SpeakerSearchTaskId" => SpeakerSearchTaskId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_profile(
SpeakerSearchTaskId,
VoiceProfileId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-profiles/$(VoiceProfileId)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("SpeakerSearchTaskId" => SpeakerSearchTaskId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_voice_profile_domain(voice_profile_domain_id)
update_voice_profile_domain(voice_profile_domain_id, params::Dict{String,<:Any})
Updates the settings for the specified voice profile domain.
# Arguments
- `voice_profile_domain_id`: The domain ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description of the voice profile domain.
- `"Name"`: The name of the voice profile domain.
"""
function update_voice_profile_domain(
VoiceProfileDomainId; aws_config::AbstractAWSConfig=global_aws_config()
)
return chime_sdk_voice(
"PUT",
"/voice-profile-domains/$(VoiceProfileDomainId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_voice_profile_domain(
VoiceProfileDomainId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"PUT",
"/voice-profile-domains/$(VoiceProfileDomainId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
validate_e911_address(aws_account_id, city, country, postal_code, state, street_info, street_number)
validate_e911_address(aws_account_id, city, country, postal_code, state, street_info, street_number, params::Dict{String,<:Any})
Validates an address to be used for 911 calls made with Amazon Chime SDK Voice Connectors.
You can use validated addresses in a Presence Information Data Format Location Object file
that you include in SIP requests. That helps ensure that addresses are routed to the
appropriate Public Safety Answering Point.
# Arguments
- `aws_account_id`: The AWS account ID.
- `city`: The address city, such as Portland.
- `country`: The country in the address being validated.
- `postal_code`: The dress postal code, such 04352.
- `state`: The address state, such as ME.
- `street_info`: The address street information, such as 8th Avenue.
- `street_number`: The address street number, such as 200 or 2121.
"""
function validate_e911_address(
AwsAccountId,
City,
Country,
PostalCode,
State,
StreetInfo,
StreetNumber;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/emergency-calling/address",
Dict{String,Any}(
"AwsAccountId" => AwsAccountId,
"City" => City,
"Country" => Country,
"PostalCode" => PostalCode,
"State" => State,
"StreetInfo" => StreetInfo,
"StreetNumber" => StreetNumber,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function validate_e911_address(
AwsAccountId,
City,
Country,
PostalCode,
State,
StreetInfo,
StreetNumber,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return chime_sdk_voice(
"POST",
"/emergency-calling/address",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AwsAccountId" => AwsAccountId,
"City" => City,
"Country" => Country,
"PostalCode" => PostalCode,
"State" => State,
"StreetInfo" => StreetInfo,
"StreetNumber" => StreetNumber,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 95414 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cleanrooms
using AWS.Compat
using AWS.UUIDs
"""
batch_get_collaboration_analysis_template(analysis_template_arns, collaboration_identifier)
batch_get_collaboration_analysis_template(analysis_template_arns, collaboration_identifier, params::Dict{String,<:Any})
Retrieves multiple analysis templates within a collaboration by their Amazon Resource Names
(ARNs).
# Arguments
- `analysis_template_arns`: The Amazon Resource Name (ARN) associated with the analysis
template within a collaboration.
- `collaboration_identifier`: A unique identifier for the collaboration that the analysis
templates belong to. Currently accepts collaboration ID.
"""
function batch_get_collaboration_analysis_template(
analysisTemplateArns,
collaborationIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-analysistemplates",
Dict{String,Any}("analysisTemplateArns" => analysisTemplateArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_collaboration_analysis_template(
analysisTemplateArns,
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-analysistemplates",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("analysisTemplateArns" => analysisTemplateArns),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_schema(collaboration_identifier, names)
batch_get_schema(collaboration_identifier, names, params::Dict{String,<:Any})
Retrieves multiple schemas by their identifiers.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the schemas
belong to. Currently accepts collaboration ID.
- `names`: The names for the schema objects to retrieve.
"""
function batch_get_schema(
collaborationIdentifier, names; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-schema",
Dict{String,Any}("names" => names);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_schema(
collaborationIdentifier,
names,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-schema",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("names" => names), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_schema_analysis_rule(collaboration_identifier, schema_analysis_rule_requests)
batch_get_schema_analysis_rule(collaboration_identifier, schema_analysis_rule_requests, params::Dict{String,<:Any})
Retrieves multiple analysis rule schemas.
# Arguments
- `collaboration_identifier`: The unique identifier of the collaboration that contains the
schema analysis rule.
- `schema_analysis_rule_requests`: The information that's necessary to retrieve a schema
analysis rule.
"""
function batch_get_schema_analysis_rule(
collaborationIdentifier,
schemaAnalysisRuleRequests;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-schema-analysis-rule",
Dict{String,Any}("schemaAnalysisRuleRequests" => schemaAnalysisRuleRequests);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_schema_analysis_rule(
collaborationIdentifier,
schemaAnalysisRuleRequests,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations/$(collaborationIdentifier)/batch-schema-analysis-rule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"schemaAnalysisRuleRequests" => schemaAnalysisRuleRequests
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_analysis_template(format, membership_identifier, name, source)
create_analysis_template(format, membership_identifier, name, source, params::Dict{String,<:Any})
Creates a new analysis template.
# Arguments
- `format`: The format of the analysis template.
- `membership_identifier`: The identifier for a membership resource.
- `name`: The name of the analysis template.
- `source`: The information in the analysis template. Currently supports text, the query
text for the analysis template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"analysisParameters"`: The parameters of the analysis template.
- `"description"`: The description of the analysis template.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_analysis_template(
format,
membershipIdentifier,
name,
source;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/analysistemplates",
Dict{String,Any}("format" => format, "name" => name, "source" => source);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_analysis_template(
format,
membershipIdentifier,
name,
source,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/analysistemplates",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("format" => format, "name" => name, "source" => source),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_collaboration(creator_display_name, creator_member_abilities, description, members, name, query_log_status)
create_collaboration(creator_display_name, creator_member_abilities, description, members, name, query_log_status, params::Dict{String,<:Any})
Creates a new collaboration.
# Arguments
- `creator_display_name`: The display name of the collaboration creator.
- `creator_member_abilities`: The abilities granted to the collaboration creator.
- `description`: A description of the collaboration provided by the collaboration owner.
- `members`: A list of initial members, not including the creator. This list is immutable.
- `name`: The display name for a collaboration.
- `query_log_status`: An indicator as to whether query logging has been enabled or disabled
for the collaboration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"creatorPaymentConfiguration"`: The collaboration creator's payment responsibilities set
by the collaboration creator. If the collaboration creator hasn't specified anyone as the
member paying for query compute costs, then the member who can query is the default payer.
- `"dataEncryptionMetadata"`: The settings for client-side encryption with Cryptographic
Computing for Clean Rooms.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_collaboration(
creatorDisplayName,
creatorMemberAbilities,
description,
members,
name,
queryLogStatus;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations",
Dict{String,Any}(
"creatorDisplayName" => creatorDisplayName,
"creatorMemberAbilities" => creatorMemberAbilities,
"description" => description,
"members" => members,
"name" => name,
"queryLogStatus" => queryLogStatus,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_collaboration(
creatorDisplayName,
creatorMemberAbilities,
description,
members,
name,
queryLogStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/collaborations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"creatorDisplayName" => creatorDisplayName,
"creatorMemberAbilities" => creatorMemberAbilities,
"description" => description,
"members" => members,
"name" => name,
"queryLogStatus" => queryLogStatus,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configured_audience_model_association(configured_audience_model_arn, configured_audience_model_association_name, manage_resource_policies, membership_identifier)
create_configured_audience_model_association(configured_audience_model_arn, configured_audience_model_association_name, manage_resource_policies, membership_identifier, params::Dict{String,<:Any})
Provides the details necessary to create a configured audience model association.
# Arguments
- `configured_audience_model_arn`: A unique identifier for the configured audience model
that you want to associate.
- `configured_audience_model_association_name`: The name of the configured audience model
association.
- `manage_resource_policies`: When TRUE, indicates that the resource policy for the
configured audience model resource being associated is configured for Clean Rooms to manage
permissions related to the given collaboration. When FALSE, indicates that the configured
audience model resource owner will manage permissions related to the given collaboration.
Setting this to TRUE requires you to have permissions to create, update, and delete the
resource policy for the cleanrooms-ml resource when you call the
DeleteConfiguredAudienceModelAssociation resource. In addition, if you are the
collaboration creator and specify TRUE, you must have the same permissions when you call
the DeleteMember and DeleteCollaboration APIs.
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The configured audience model is associated to the collaboration that this
membership belongs to. Accepts a membership ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the configured audience model association.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_configured_audience_model_association(
configuredAudienceModelArn,
configuredAudienceModelAssociationName,
manageResourcePolicies,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations",
Dict{String,Any}(
"configuredAudienceModelArn" => configuredAudienceModelArn,
"configuredAudienceModelAssociationName" =>
configuredAudienceModelAssociationName,
"manageResourcePolicies" => manageResourcePolicies,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configured_audience_model_association(
configuredAudienceModelArn,
configuredAudienceModelAssociationName,
manageResourcePolicies,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configuredAudienceModelArn" => configuredAudienceModelArn,
"configuredAudienceModelAssociationName" =>
configuredAudienceModelAssociationName,
"manageResourcePolicies" => manageResourcePolicies,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configured_table(allowed_columns, analysis_method, name, table_reference)
create_configured_table(allowed_columns, analysis_method, name, table_reference, params::Dict{String,<:Any})
Creates a new configured table resource.
# Arguments
- `allowed_columns`: The columns of the underlying table that can be used by collaborations
or analysis rules.
- `analysis_method`: The analysis method for the configured tables. The only valid value is
currently `DIRECT_QUERY`.
- `name`: The name of the configured table.
- `table_reference`: A reference to the Glue table being configured.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description for the configured table.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_configured_table(
allowedColumns,
analysisMethod,
name,
tableReference;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/configuredTables",
Dict{String,Any}(
"allowedColumns" => allowedColumns,
"analysisMethod" => analysisMethod,
"name" => name,
"tableReference" => tableReference,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configured_table(
allowedColumns,
analysisMethod,
name,
tableReference,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/configuredTables",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"allowedColumns" => allowedColumns,
"analysisMethod" => analysisMethod,
"name" => name,
"tableReference" => tableReference,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configured_table_analysis_rule(analysis_rule_policy, analysis_rule_type, configured_table_identifier)
create_configured_table_analysis_rule(analysis_rule_policy, analysis_rule_type, configured_table_identifier, params::Dict{String,<:Any})
Creates a new analysis rule for a configured table. Currently, only one analysis rule can
be created for a given configured table.
# Arguments
- `analysis_rule_policy`: The entire created configured table analysis rule object.
- `analysis_rule_type`: The type of analysis rule.
- `configured_table_identifier`: The identifier for the configured table to create the
analysis rule for. Currently accepts the configured table ID.
"""
function create_configured_table_analysis_rule(
analysisRulePolicy,
analysisRuleType,
configuredTableIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/configuredTables/$(configuredTableIdentifier)/analysisRule",
Dict{String,Any}(
"analysisRulePolicy" => analysisRulePolicy,
"analysisRuleType" => analysisRuleType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configured_table_analysis_rule(
analysisRulePolicy,
analysisRuleType,
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/configuredTables/$(configuredTableIdentifier)/analysisRule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"analysisRulePolicy" => analysisRulePolicy,
"analysisRuleType" => analysisRuleType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configured_table_association(configured_table_identifier, membership_identifier, name, role_arn)
create_configured_table_association(configured_table_identifier, membership_identifier, name, role_arn, params::Dict{String,<:Any})
Creates a configured table association. A configured table association links a configured
table with a collaboration.
# Arguments
- `configured_table_identifier`: A unique identifier for the configured table to be
associated to. Currently accepts a configured table ID.
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The configured table is associated to the collaboration that this membership
belongs to. Currently accepts a membership ID.
- `name`: The name of the configured table association. This name is used to query the
underlying configured table.
- `role_arn`: The service will assume this role to access catalog metadata and query the
table.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description for the configured table association.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_configured_table_association(
configuredTableIdentifier,
membershipIdentifier,
name,
roleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/configuredTableAssociations",
Dict{String,Any}(
"configuredTableIdentifier" => configuredTableIdentifier,
"name" => name,
"roleArn" => roleArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configured_table_association(
configuredTableIdentifier,
membershipIdentifier,
name,
roleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/configuredTableAssociations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configuredTableIdentifier" => configuredTableIdentifier,
"name" => name,
"roleArn" => roleArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_membership(collaboration_identifier, query_log_status)
create_membership(collaboration_identifier, query_log_status, params::Dict{String,<:Any})
Creates a membership for a specific collaboration identifier and joins the collaboration.
# Arguments
- `collaboration_identifier`: The unique ID for the associated collaboration.
- `query_log_status`: An indicator as to whether query logging has been enabled or disabled
for the membership.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"defaultResultConfiguration"`: The default protected query result configuration as
specified by the member who can receive results.
- `"paymentConfiguration"`: The payment responsibilities accepted by the collaboration
member. Not required if the collaboration member has the member ability to run queries.
Required if the collaboration member doesn't have the member ability to run queries but is
configured as a payer by the collaboration creator.
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_membership(
collaborationIdentifier,
queryLogStatus;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships",
Dict{String,Any}(
"collaborationIdentifier" => collaborationIdentifier,
"queryLogStatus" => queryLogStatus,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_membership(
collaborationIdentifier,
queryLogStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"collaborationIdentifier" => collaborationIdentifier,
"queryLogStatus" => queryLogStatus,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_privacy_budget_template(auto_refresh, membership_identifier, parameters, privacy_budget_type)
create_privacy_budget_template(auto_refresh, membership_identifier, parameters, privacy_budget_type, params::Dict{String,<:Any})
Creates a privacy budget template for a specified membership. Each membership can have only
one privacy budget template, but it can be deleted and recreated. If you need to change the
privacy budget template for a membership, use the UpdatePrivacyBudgetTemplate operation.
# Arguments
- `auto_refresh`: How often the privacy budget refreshes. If you plan to regularly bring
new data into the collaboration, you can use CALENDAR_MONTH to automatically get a new
privacy budget for the collaboration every calendar month. Choosing this option allows
arbitrary amounts of information to be revealed about rows of the data when repeatedly
queries across refreshes. Avoid choosing this if the same rows will be repeatedly queried
between privacy budget refreshes.
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget template is created in the collaboration that this
membership belongs to. Accepts a membership ID.
- `parameters`: Specifies your parameters for the privacy budget template.
- `privacy_budget_type`: Specifies the type of the privacy budget template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: An optional label that you can assign to a resource when you create it. Each
tag consists of a key and an optional value, both of which you define. When you use
tagging, you can also use tag-based access control in IAM policies to control access to
this resource.
"""
function create_privacy_budget_template(
autoRefresh,
membershipIdentifier,
parameters,
privacyBudgetType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/privacybudgettemplates",
Dict{String,Any}(
"autoRefresh" => autoRefresh,
"parameters" => parameters,
"privacyBudgetType" => privacyBudgetType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_privacy_budget_template(
autoRefresh,
membershipIdentifier,
parameters,
privacyBudgetType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/privacybudgettemplates",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"autoRefresh" => autoRefresh,
"parameters" => parameters,
"privacyBudgetType" => privacyBudgetType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_analysis_template(analysis_template_identifier, membership_identifier)
delete_analysis_template(analysis_template_identifier, membership_identifier, params::Dict{String,<:Any})
Deletes an analysis template.
# Arguments
- `analysis_template_identifier`: The identifier for the analysis template resource.
- `membership_identifier`: The identifier for a membership resource.
"""
function delete_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_collaboration(collaboration_identifier)
delete_collaboration(collaboration_identifier, params::Dict{String,<:Any})
Deletes a collaboration. It can only be called by the collaboration owner.
# Arguments
- `collaboration_identifier`: The identifier for the collaboration.
"""
function delete_collaboration(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"DELETE",
"/collaborations/$(collaborationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_collaboration(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/collaborations/$(collaborationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier)
delete_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier, params::Dict{String,<:Any})
Provides the information necessary to delete a configured audience model association.
# Arguments
- `configured_audience_model_association_identifier`: A unique identifier of the configured
audience model association that you want to delete.
- `membership_identifier`: A unique identifier of the membership that contains the audience
model association that you want to delete.
"""
function delete_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_table(configured_table_identifier)
delete_configured_table(configured_table_identifier, params::Dict{String,<:Any})
Deletes a configured table.
# Arguments
- `configured_table_identifier`: The unique ID for the configured table to delete.
"""
function delete_configured_table(
configuredTableIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"DELETE",
"/configuredTables/$(configuredTableIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_table(
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/configuredTables/$(configuredTableIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_table_analysis_rule(analysis_rule_type, configured_table_identifier)
delete_configured_table_analysis_rule(analysis_rule_type, configured_table_identifier, params::Dict{String,<:Any})
Deletes a configured table analysis rule.
# Arguments
- `analysis_rule_type`: The analysis rule type to be deleted. Configured table analysis
rules are uniquely identified by their configured table identifier and analysis rule type.
- `configured_table_identifier`: The unique identifier for the configured table that the
analysis rule applies to. Currently accepts the configured table ID.
"""
function delete_configured_table_analysis_rule(
analysisRuleType,
configuredTableIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_table_analysis_rule(
analysisRuleType,
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_table_association(configured_table_association_identifier, membership_identifier)
delete_configured_table_association(configured_table_association_identifier, membership_identifier, params::Dict{String,<:Any})
Deletes a configured table association.
# Arguments
- `configured_table_association_identifier`: The unique ID for the configured table
association to be deleted. Currently accepts the configured table ID.
- `membership_identifier`: A unique identifier for the membership that the configured table
association belongs to. Currently accepts the membership ID.
"""
function delete_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_member(account_id, collaboration_identifier)
delete_member(account_id, collaboration_identifier, params::Dict{String,<:Any})
Removes the specified member from a collaboration. The removed member is placed in the
Removed status and can't interact with the collaboration. The removed member's data is
inaccessible to active members of the collaboration.
# Arguments
- `account_id`: The account ID of the member to remove.
- `collaboration_identifier`: The unique identifier for the associated collaboration.
"""
function delete_member(
accountId, collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"DELETE",
"/collaborations/$(collaborationIdentifier)/member/$(accountId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_member(
accountId,
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/collaborations/$(collaborationIdentifier)/member/$(accountId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_membership(membership_identifier)
delete_membership(membership_identifier, params::Dict{String,<:Any})
Deletes a specified membership. All resources under a membership must be deleted.
# Arguments
- `membership_identifier`: The identifier for a membership resource.
"""
function delete_membership(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_membership(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_privacy_budget_template(membership_identifier, privacy_budget_template_identifier)
delete_privacy_budget_template(membership_identifier, privacy_budget_template_identifier, params::Dict{String,<:Any})
Deletes a privacy budget template for a specified membership.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget template is deleted from the collaboration that this
membership belongs to. Accepts a membership ID.
- `privacy_budget_template_identifier`: A unique identifier for your privacy budget
template.
"""
function delete_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_analysis_template(analysis_template_identifier, membership_identifier)
get_analysis_template(analysis_template_identifier, membership_identifier, params::Dict{String,<:Any})
Retrieves an analysis template.
# Arguments
- `analysis_template_identifier`: The identifier for the analysis template resource.
- `membership_identifier`: The identifier for a membership resource.
"""
function get_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_collaboration(collaboration_identifier)
get_collaboration(collaboration_identifier, params::Dict{String,<:Any})
Returns metadata about a collaboration.
# Arguments
- `collaboration_identifier`: The identifier for the collaboration.
"""
function get_collaboration(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_collaboration(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_collaboration_analysis_template(analysis_template_arn, collaboration_identifier)
get_collaboration_analysis_template(analysis_template_arn, collaboration_identifier, params::Dict{String,<:Any})
Retrieves an analysis template within a collaboration.
# Arguments
- `analysis_template_arn`: The Amazon Resource Name (ARN) associated with the analysis
template within a collaboration.
- `collaboration_identifier`: A unique identifier for the collaboration that the analysis
templates belong to. Currently accepts collaboration ID.
"""
function get_collaboration_analysis_template(
analysisTemplateArn,
collaborationIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/analysistemplates/$(analysisTemplateArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_collaboration_analysis_template(
analysisTemplateArn,
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/analysistemplates/$(analysisTemplateArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_collaboration_configured_audience_model_association(collaboration_identifier, configured_audience_model_association_identifier)
get_collaboration_configured_audience_model_association(collaboration_identifier, configured_audience_model_association_identifier, params::Dict{String,<:Any})
Retrieves a configured audience model association within a collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the configured
audience model association belongs to. Accepts a collaboration ID.
- `configured_audience_model_association_identifier`: A unique identifier for the
configured audience model association that you want to retrieve.
"""
function get_collaboration_configured_audience_model_association(
collaborationIdentifier,
configuredAudienceModelAssociationIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_collaboration_configured_audience_model_association(
collaborationIdentifier,
configuredAudienceModelAssociationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_collaboration_privacy_budget_template(collaboration_identifier, privacy_budget_template_identifier)
get_collaboration_privacy_budget_template(collaboration_identifier, privacy_budget_template_identifier, params::Dict{String,<:Any})
Returns details about a specified privacy budget template.
# Arguments
- `collaboration_identifier`: A unique identifier for one of your collaborations.
- `privacy_budget_template_identifier`: A unique identifier for one of your privacy budget
templates.
"""
function get_collaboration_privacy_budget_template(
collaborationIdentifier,
privacyBudgetTemplateIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_collaboration_privacy_budget_template(
collaborationIdentifier,
privacyBudgetTemplateIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier)
get_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier, params::Dict{String,<:Any})
Returns information about a configured audience model association.
# Arguments
- `configured_audience_model_association_identifier`: A unique identifier for the
configured audience model association that you want to retrieve.
- `membership_identifier`: A unique identifier for the membership that contains the
configured audience model association that you want to retrieve.
"""
function get_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_table(configured_table_identifier)
get_configured_table(configured_table_identifier, params::Dict{String,<:Any})
Retrieves a configured table.
# Arguments
- `configured_table_identifier`: The unique ID for the configured table to retrieve.
"""
function get_configured_table(
configuredTableIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/configuredTables/$(configuredTableIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_table(
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/configuredTables/$(configuredTableIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_table_analysis_rule(analysis_rule_type, configured_table_identifier)
get_configured_table_analysis_rule(analysis_rule_type, configured_table_identifier, params::Dict{String,<:Any})
Retrieves a configured table analysis rule.
# Arguments
- `analysis_rule_type`: The analysis rule to be retrieved. Configured table analysis rules
are uniquely identified by their configured table identifier and analysis rule type.
- `configured_table_identifier`: The unique identifier for the configured table to
retrieve. Currently accepts the configured table ID.
"""
function get_configured_table_analysis_rule(
analysisRuleType,
configuredTableIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_table_analysis_rule(
analysisRuleType,
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_table_association(configured_table_association_identifier, membership_identifier)
get_configured_table_association(configured_table_association_identifier, membership_identifier, params::Dict{String,<:Any})
Retrieves a configured table association.
# Arguments
- `configured_table_association_identifier`: The unique ID for the configured table
association to retrieve. Currently accepts the configured table ID.
- `membership_identifier`: A unique identifier for the membership that the configured table
association belongs to. Currently accepts the membership ID.
"""
function get_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_membership(membership_identifier)
get_membership(membership_identifier, params::Dict{String,<:Any})
Retrieves a specified membership for an identifier.
# Arguments
- `membership_identifier`: The identifier for a membership resource.
"""
function get_membership(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_membership(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_privacy_budget_template(membership_identifier, privacy_budget_template_identifier)
get_privacy_budget_template(membership_identifier, privacy_budget_template_identifier, params::Dict{String,<:Any})
Returns details for a specified privacy budget template.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget template is retrieved from the collaboration that this
membership belongs to. Accepts a membership ID.
- `privacy_budget_template_identifier`: A unique identifier for your privacy budget
template.
"""
function get_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_protected_query(membership_identifier, protected_query_identifier)
get_protected_query(membership_identifier, protected_query_identifier, params::Dict{String,<:Any})
Returns query processing metadata.
# Arguments
- `membership_identifier`: The identifier for a membership in a protected query instance.
- `protected_query_identifier`: The identifier for a protected query instance.
"""
function get_protected_query(
membershipIdentifier,
protectedQueryIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/protectedQueries/$(protectedQueryIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_protected_query(
membershipIdentifier,
protectedQueryIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/protectedQueries/$(protectedQueryIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_schema(collaboration_identifier, name)
get_schema(collaboration_identifier, name, params::Dict{String,<:Any})
Retrieves the schema for a relation within a collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the schema
belongs to. Currently accepts a collaboration ID.
- `name`: The name of the relation to retrieve the schema for.
"""
function get_schema(
collaborationIdentifier, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_schema(
collaborationIdentifier,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_schema_analysis_rule(collaboration_identifier, name, type)
get_schema_analysis_rule(collaboration_identifier, name, type, params::Dict{String,<:Any})
Retrieves a schema analysis rule.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the schema
belongs to. Currently accepts a collaboration ID.
- `name`: The name of the schema to retrieve the analysis rule for.
- `type`: The type of the schema analysis rule to retrieve. Schema analysis rules are
uniquely identified by a combination of the collaboration, the schema name, and their type.
"""
function get_schema_analysis_rule(
collaborationIdentifier, name, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas/$(name)/analysisRule/$(type)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_schema_analysis_rule(
collaborationIdentifier,
name,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas/$(name)/analysisRule/$(type)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_analysis_templates(membership_identifier)
list_analysis_templates(membership_identifier, params::Dict{String,<:Any})
Lists analysis templates that the caller owns.
# Arguments
- `membership_identifier`: The identifier for a membership resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_analysis_templates(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/analysistemplates";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_analysis_templates(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/analysistemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_collaboration_analysis_templates(collaboration_identifier)
list_collaboration_analysis_templates(collaboration_identifier, params::Dict{String,<:Any})
Lists analysis templates within a collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the analysis
templates belong to. Currently accepts collaboration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_collaboration_analysis_templates(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/analysistemplates";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_collaboration_analysis_templates(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/analysistemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_collaboration_configured_audience_model_associations(collaboration_identifier)
list_collaboration_configured_audience_model_associations(collaboration_identifier, params::Dict{String,<:Any})
Lists configured audience model associations within a collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the configured
audience model association belongs to. Accepts a collaboration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_collaboration_configured_audience_model_associations(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/configuredaudiencemodelassociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_collaboration_configured_audience_model_associations(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/configuredaudiencemodelassociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_collaboration_privacy_budget_templates(collaboration_identifier)
list_collaboration_privacy_budget_templates(collaboration_identifier, params::Dict{String,<:Any})
Returns an array that summarizes each privacy budget template in a specified collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for one of your collaborations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_collaboration_privacy_budget_templates(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgettemplates";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_collaboration_privacy_budget_templates(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgettemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_collaboration_privacy_budgets(collaboration_identifier, privacy_budget_type)
list_collaboration_privacy_budgets(collaboration_identifier, privacy_budget_type, params::Dict{String,<:Any})
Returns an array that summarizes each privacy budget in a specified collaboration. The
summary includes the collaboration ARN, creation time, creating account, and privacy budget
details.
# Arguments
- `collaboration_identifier`: A unique identifier for one of your collaborations.
- `privacy_budget_type`: Specifies the type of the privacy budget.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_collaboration_privacy_budgets(
collaborationIdentifier,
privacyBudgetType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgets",
Dict{String,Any}("privacyBudgetType" => privacyBudgetType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_collaboration_privacy_budgets(
collaborationIdentifier,
privacyBudgetType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/privacybudgets",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("privacyBudgetType" => privacyBudgetType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_collaborations()
list_collaborations(params::Dict{String,<:Any})
Lists collaborations the caller owns, is active in, or has been invited to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"memberStatus"`: The caller's status in a collaboration.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_collaborations(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanrooms(
"GET", "/collaborations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_collaborations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configured_audience_model_associations(membership_identifier)
list_configured_audience_model_associations(membership_identifier, params::Dict{String,<:Any})
Lists information about requested configured audience model associations.
# Arguments
- `membership_identifier`: A unique identifier for a membership that contains the
configured audience model associations that you want to retrieve.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_configured_audience_model_associations(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_configured_audience_model_associations(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configured_table_associations(membership_identifier)
list_configured_table_associations(membership_identifier, params::Dict{String,<:Any})
Lists configured table associations for a membership.
# Arguments
- `membership_identifier`: A unique identifier for the membership to list configured table
associations for. Currently accepts the membership ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_configured_table_associations(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredTableAssociations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_configured_table_associations(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/configuredTableAssociations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configured_tables()
list_configured_tables(params::Dict{String,<:Any})
Lists configured tables.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_configured_tables(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanrooms(
"GET", "/configuredTables"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_configured_tables(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/configuredTables",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_members(collaboration_identifier)
list_members(collaboration_identifier, params::Dict{String,<:Any})
Lists all members within a collaboration.
# Arguments
- `collaboration_identifier`: The identifier of the collaboration in which the members are
listed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_members(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/members";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_members(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/members",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_memberships()
list_memberships(params::Dict{String,<:Any})
Lists all memberships resources within the caller's account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
- `"status"`: A filter which will return only memberships in the specified status.
"""
function list_memberships(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanrooms(
"GET", "/memberships"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_memberships(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_privacy_budget_templates(membership_identifier)
list_privacy_budget_templates(membership_identifier, params::Dict{String,<:Any})
Returns detailed information about the privacy budget templates in a specified membership.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget templates are retrieved from the collaboration that this
membership belongs to. Accepts a membership ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_privacy_budget_templates(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgettemplates";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_privacy_budget_templates(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgettemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_privacy_budgets(membership_identifier, privacy_budget_type)
list_privacy_budgets(membership_identifier, privacy_budget_type, params::Dict{String,<:Any})
Returns detailed information about the privacy budgets in a specified membership.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget is retrieved from the collaboration that this membership
belongs to. Accepts a membership ID.
- `privacy_budget_type`: The privacy budget type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service may return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_privacy_budgets(
membershipIdentifier,
privacyBudgetType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgets",
Dict{String,Any}("privacyBudgetType" => privacyBudgetType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_privacy_budgets(
membershipIdentifier,
privacyBudgetType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/privacybudgets",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("privacyBudgetType" => privacyBudgetType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_protected_queries(membership_identifier)
list_protected_queries(membership_identifier, params::Dict{String,<:Any})
Lists protected queries, sorted by the most recent query.
# Arguments
- `membership_identifier`: The identifier for the membership in the collaboration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call. Service
chooses a default if it has not been set. Service can return a nextToken even if the
maximum results has not been met.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
- `"status"`: A filter on the status of the protected query.
"""
function list_protected_queries(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/protectedQueries";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_protected_queries(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/memberships/$(membershipIdentifier)/protectedQueries",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_schemas(collaboration_identifier)
list_schemas(collaboration_identifier, params::Dict{String,<:Any})
Lists the schemas for relations within a collaboration.
# Arguments
- `collaboration_identifier`: A unique identifier for the collaboration that the schema
belongs to. Currently accepts a collaboration ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
- `"schemaType"`: If present, filter schemas by schema type. The only valid schema type is
currently `TABLE`.
"""
function list_schemas(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_schemas(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/collaborations/$(collaborationIdentifier)/schemas",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Lists all of the tags that have been added to a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) associated with the resource you want to
list tags on.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
preview_privacy_impact(membership_identifier, parameters)
preview_privacy_impact(membership_identifier, parameters, params::Dict{String,<:Any})
An estimate of the number of aggregation functions that the member who can query can run
given epsilon and noise parameters.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. Accepts a membership ID.
- `parameters`: Specifies the desired epsilon and noise parameters to preview.
"""
function preview_privacy_impact(
membershipIdentifier, parameters; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/previewprivacyimpact",
Dict{String,Any}("parameters" => parameters);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function preview_privacy_impact(
membershipIdentifier,
parameters,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/previewprivacyimpact",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("parameters" => parameters), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_protected_query(membership_identifier, sql_parameters, type)
start_protected_query(membership_identifier, sql_parameters, type, params::Dict{String,<:Any})
Creates a protected query that is started by Clean Rooms.
# Arguments
- `membership_identifier`: A unique identifier for the membership to run this query
against. Currently accepts a membership ID.
- `sql_parameters`: The protected SQL query parameters.
- `type`: The type of the protected query to be started.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resultConfiguration"`: The details needed to write the query results.
"""
function start_protected_query(
membershipIdentifier,
sqlParameters,
type;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/protectedQueries",
Dict{String,Any}("sqlParameters" => sqlParameters, "type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_protected_query(
membershipIdentifier,
sqlParameters,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/memberships/$(membershipIdentifier)/protectedQueries",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("sqlParameters" => sqlParameters, "type" => type),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Tags a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) associated with the resource you want to
tag.
- `tags`: A map of objects specifying each key name and value.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return cleanrooms(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag or list of tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) associated with the resource you want to
remove the tag from.
- `tag_keys`: A list of key names of tags to be removed.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_analysis_template(analysis_template_identifier, membership_identifier)
update_analysis_template(analysis_template_identifier, membership_identifier, params::Dict{String,<:Any})
Updates the analysis template metadata.
# Arguments
- `analysis_template_identifier`: The identifier for the analysis template resource.
- `membership_identifier`: The identifier for a membership resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A new description for the analysis template.
"""
function update_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_analysis_template(
analysisTemplateIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/analysistemplates/$(analysisTemplateIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_collaboration(collaboration_identifier)
update_collaboration(collaboration_identifier, params::Dict{String,<:Any})
Updates collaboration metadata and can only be called by the collaboration owner.
# Arguments
- `collaboration_identifier`: The identifier for the collaboration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the collaboration.
- `"name"`: A human-readable identifier provided by the collaboration owner. Display names
are not unique.
"""
function update_collaboration(
collaborationIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"PATCH",
"/collaborations/$(collaborationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_collaboration(
collaborationIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/collaborations/$(collaborationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier)
update_configured_audience_model_association(configured_audience_model_association_identifier, membership_identifier, params::Dict{String,<:Any})
Provides the details necessary to update a configured audience model association.
# Arguments
- `configured_audience_model_association_identifier`: A unique identifier for the
configured audience model association that you want to update.
- `membership_identifier`: A unique identifier of the membership that contains the
configured audience model association that you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A new description for the configured audience model association.
- `"name"`: A new name for the configured audience model association.
"""
function update_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configured_audience_model_association(
configuredAudienceModelAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/configuredaudiencemodelassociations/$(configuredAudienceModelAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configured_table(configured_table_identifier)
update_configured_table(configured_table_identifier, params::Dict{String,<:Any})
Updates a configured table.
# Arguments
- `configured_table_identifier`: The identifier for the configured table to update.
Currently accepts the configured table ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A new description for the configured table.
- `"name"`: A new name for the configured table.
"""
function update_configured_table(
configuredTableIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"PATCH",
"/configuredTables/$(configuredTableIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configured_table(
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/configuredTables/$(configuredTableIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configured_table_analysis_rule(analysis_rule_policy, analysis_rule_type, configured_table_identifier)
update_configured_table_analysis_rule(analysis_rule_policy, analysis_rule_type, configured_table_identifier, params::Dict{String,<:Any})
Updates a configured table analysis rule.
# Arguments
- `analysis_rule_policy`: The new analysis rule policy for the configured table analysis
rule.
- `analysis_rule_type`: The analysis rule type to be updated. Configured table analysis
rules are uniquely identified by their configured table identifier and analysis rule type.
- `configured_table_identifier`: The unique identifier for the configured table that the
analysis rule applies to. Currently accepts the configured table ID.
"""
function update_configured_table_analysis_rule(
analysisRulePolicy,
analysisRuleType,
configuredTableIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)",
Dict{String,Any}("analysisRulePolicy" => analysisRulePolicy);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configured_table_analysis_rule(
analysisRulePolicy,
analysisRuleType,
configuredTableIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/configuredTables/$(configuredTableIdentifier)/analysisRule/$(analysisRuleType)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("analysisRulePolicy" => analysisRulePolicy), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configured_table_association(configured_table_association_identifier, membership_identifier)
update_configured_table_association(configured_table_association_identifier, membership_identifier, params::Dict{String,<:Any})
Updates a configured table association.
# Arguments
- `configured_table_association_identifier`: The unique identifier for the configured table
association to update. Currently accepts the configured table association ID.
- `membership_identifier`: The unique ID for the membership that the configured table
association belongs to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A new description for the configured table association.
- `"roleArn"`: The service will assume this role to access catalog metadata and query the
table.
"""
function update_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configured_table_association(
configuredTableAssociationIdentifier,
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/configuredTableAssociations/$(configuredTableAssociationIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_membership(membership_identifier)
update_membership(membership_identifier, params::Dict{String,<:Any})
Updates a membership.
# Arguments
- `membership_identifier`: The unique identifier of the membership.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"defaultResultConfiguration"`: The default protected query result configuration as
specified by the member who can receive results.
- `"queryLogStatus"`: An indicator as to whether query logging has been enabled or disabled
for the membership.
"""
function update_membership(
membershipIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_membership(
membershipIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_privacy_budget_template(membership_identifier, privacy_budget_template_identifier, privacy_budget_type)
update_privacy_budget_template(membership_identifier, privacy_budget_template_identifier, privacy_budget_type, params::Dict{String,<:Any})
Updates the privacy budget template for the specified membership.
# Arguments
- `membership_identifier`: A unique identifier for one of your memberships for a
collaboration. The privacy budget template is updated in the collaboration that this
membership belongs to. Accepts a membership ID.
- `privacy_budget_template_identifier`: A unique identifier for your privacy budget
template that you want to update.
- `privacy_budget_type`: Specifies the type of the privacy budget template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"parameters"`: Specifies the epsilon and noise parameters for the privacy budget
template.
"""
function update_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier,
privacyBudgetType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)",
Dict{String,Any}("privacyBudgetType" => privacyBudgetType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_privacy_budget_template(
membershipIdentifier,
privacyBudgetTemplateIdentifier,
privacyBudgetType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/privacybudgettemplates/$(privacyBudgetTemplateIdentifier)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("privacyBudgetType" => privacyBudgetType), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_protected_query(membership_identifier, protected_query_identifier, target_status)
update_protected_query(membership_identifier, protected_query_identifier, target_status, params::Dict{String,<:Any})
Updates the processing of a currently running query.
# Arguments
- `membership_identifier`: The identifier for a member of a protected query instance.
- `protected_query_identifier`: The identifier for a protected query instance.
- `target_status`: The target status of a query. Used to update the execution status of a
currently running query.
"""
function update_protected_query(
membershipIdentifier,
protectedQueryIdentifier,
targetStatus;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/protectedQueries/$(protectedQueryIdentifier)",
Dict{String,Any}("targetStatus" => targetStatus);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_protected_query(
membershipIdentifier,
protectedQueryIdentifier,
targetStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanrooms(
"PATCH",
"/memberships/$(membershipIdentifier)/protectedQueries/$(protectedQueryIdentifier)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("targetStatus" => targetStatus), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 40926 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cleanroomsml
using AWS.Compat
using AWS.UUIDs
"""
create_audience_model(name, training_dataset_arn)
create_audience_model(name, training_dataset_arn, params::Dict{String,<:Any})
Defines the information necessary to create an audience model. An audience model is a
machine learning model that Clean Rooms ML trains to measure similarity between users.
Clean Rooms ML manages training and storing the audience model. The audience model can be
used in multiple calls to the StartAudienceGenerationJob API.
# Arguments
- `name`: The name of the audience model resource.
- `training_dataset_arn`: The Amazon Resource Name (ARN) of the training dataset for this
audience model.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the audience model.
- `"kmsKeyArn"`: The Amazon Resource Name (ARN) of the KMS key. This key is used to encrypt
and decrypt customer-owned data in the trained ML model and the associated data.
- `"tags"`: The optional metadata that you apply to the resource to help you categorize and
organize them. Each tag consists of a key and an optional value, both of which you define.
The following basic restrictions apply to tags: Maximum number of tags per resource - 50.
For each resource, each tag key must be unique, and each tag key can have only one value.
Maximum key length - 128 Unicode characters in UTF-8. Maximum value length - 256
Unicode characters in UTF-8. If your tagging schema is used across multiple services and
resources, remember that other services may have restrictions on allowed characters.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following characters: + - = . _ : / @. Tag keys and values are case sensitive. Do
not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as
it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can
have this prefix. If a tag value has aws as its prefix but the key does not, then Clean
Rooms ML considers it to be a user tag and will count against the limit of 50 tags. Tags
with only the key prefix of aws do not count against your tags per resource limit.
- `"trainingDataEndTime"`: The end date and time of the training window.
- `"trainingDataStartTime"`: The start date and time of the training window.
"""
function create_audience_model(
name, trainingDatasetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"POST",
"/audience-model",
Dict{String,Any}("name" => name, "trainingDatasetArn" => trainingDatasetArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_audience_model(
name,
trainingDatasetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/audience-model",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name, "trainingDatasetArn" => trainingDatasetArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_configured_audience_model(audience_model_arn, name, output_config, shared_audience_metrics)
create_configured_audience_model(audience_model_arn, name, output_config, shared_audience_metrics, params::Dict{String,<:Any})
Defines the information necessary to create a configured audience model.
# Arguments
- `audience_model_arn`: The Amazon Resource Name (ARN) of the audience model to use for the
configured audience model.
- `name`: The name of the configured audience model.
- `output_config`: Configure the Amazon S3 location and IAM Role for audiences created
using this configured audience model. Each audience will have a unique location. The IAM
Role must have s3:PutObject permission on the destination Amazon S3 location. If the
destination is protected with Amazon S3 KMS-SSE, then the Role must also have the required
KMS permissions.
- `shared_audience_metrics`: Whether audience metrics are shared.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"audienceSizeConfig"`: Configure the list of output sizes of audiences that can be
created using this configured audience model. A request to StartAudienceGenerationJob that
uses this configured audience model must have an audienceSize selected from this list. You
can use the ABSOLUTE AudienceSize to configure out audience sizes using the count of
identifiers in the output. You can use the Percentage AudienceSize to configure sizes in
the range 1-100 percent.
- `"childResourceTagOnCreatePolicy"`: Configure how the service tags audience generation
jobs created using this configured audience model. If you specify NONE, the tags from the
StartAudienceGenerationJob request determine the tags of the audience generation job. If
you specify FROM_PARENT_RESOURCE, the audience generation job inherits the tags from the
configured audience model, by default. Tags in the StartAudienceGenerationJob will override
the default. When the client is in a different account than the configured audience model,
the tags from the client are never applied to a resource in the caller's account.
- `"description"`: The description of the configured audience model.
- `"minMatchingSeedSize"`: The minimum number of users from the seed audience that must
match with users in the training data of the audience model. The default value is 500.
- `"tags"`: The optional metadata that you apply to the resource to help you categorize and
organize them. Each tag consists of a key and an optional value, both of which you define.
The following basic restrictions apply to tags: Maximum number of tags per resource - 50.
For each resource, each tag key must be unique, and each tag key can have only one value.
Maximum key length - 128 Unicode characters in UTF-8. Maximum value length - 256
Unicode characters in UTF-8. If your tagging schema is used across multiple services and
resources, remember that other services may have restrictions on allowed characters.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following characters: + - = . _ : / @. Tag keys and values are case sensitive. Do
not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as
it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can
have this prefix. If a tag value has aws as its prefix but the key does not, then Clean
Rooms ML considers it to be a user tag and will count against the limit of 50 tags. Tags
with only the key prefix of aws do not count against your tags per resource limit.
"""
function create_configured_audience_model(
audienceModelArn,
name,
outputConfig,
sharedAudienceMetrics;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/configured-audience-model",
Dict{String,Any}(
"audienceModelArn" => audienceModelArn,
"name" => name,
"outputConfig" => outputConfig,
"sharedAudienceMetrics" => sharedAudienceMetrics,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_configured_audience_model(
audienceModelArn,
name,
outputConfig,
sharedAudienceMetrics,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/configured-audience-model",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"audienceModelArn" => audienceModelArn,
"name" => name,
"outputConfig" => outputConfig,
"sharedAudienceMetrics" => sharedAudienceMetrics,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_training_dataset(name, role_arn, training_data)
create_training_dataset(name, role_arn, training_data, params::Dict{String,<:Any})
Defines the information necessary to create a training dataset. In Clean Rooms ML, the
TrainingDataset is metadata that points to a Glue table, which is read only during
AudienceModel creation.
# Arguments
- `name`: The name of the training dataset. This name must be unique in your account and
region.
- `role_arn`: The ARN of the IAM role that Clean Rooms ML can assume to read the data
referred to in the dataSource field of each dataset. Passing a role across AWS accounts is
not allowed. If you pass a role that isn't in your account, you get an
AccessDeniedException error.
- `training_data`: An array of information that lists the Dataset objects, which specifies
the dataset type and details on its location and schema. You must provide a role that has
read access to these tables.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the training dataset.
- `"tags"`: The optional metadata that you apply to the resource to help you categorize and
organize them. Each tag consists of a key and an optional value, both of which you define.
The following basic restrictions apply to tags: Maximum number of tags per resource - 50.
For each resource, each tag key must be unique, and each tag key can have only one value.
Maximum key length - 128 Unicode characters in UTF-8. Maximum value length - 256
Unicode characters in UTF-8. If your tagging schema is used across multiple services and
resources, remember that other services may have restrictions on allowed characters.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following characters: + - = . _ : / @. Tag keys and values are case sensitive. Do
not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as
it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can
have this prefix. If a tag value has aws as its prefix but the key does not, then Clean
Rooms ML considers it to be a user tag and will count against the limit of 50 tags. Tags
with only the key prefix of aws do not count against your tags per resource limit.
"""
function create_training_dataset(
name, roleArn, trainingData; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"POST",
"/training-dataset",
Dict{String,Any}(
"name" => name, "roleArn" => roleArn, "trainingData" => trainingData
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_training_dataset(
name,
roleArn,
trainingData,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/training-dataset",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name, "roleArn" => roleArn, "trainingData" => trainingData
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_audience_generation_job(audience_generation_job_arn)
delete_audience_generation_job(audience_generation_job_arn, params::Dict{String,<:Any})
Deletes the specified audience generation job, and removes all data associated with the job.
# Arguments
- `audience_generation_job_arn`: The Amazon Resource Name (ARN) of the audience generation
job that you want to delete.
"""
function delete_audience_generation_job(
audienceGenerationJobArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/audience-generation-job/$(audienceGenerationJobArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_audience_generation_job(
audienceGenerationJobArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/audience-generation-job/$(audienceGenerationJobArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_audience_model(audience_model_arn)
delete_audience_model(audience_model_arn, params::Dict{String,<:Any})
Specifies an audience model that you want to delete. You can't delete an audience model if
there are any configured audience models that depend on the audience model.
# Arguments
- `audience_model_arn`: The Amazon Resource Name (ARN) of the audience model that you want
to delete.
"""
function delete_audience_model(
audienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/audience-model/$(audienceModelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_audience_model(
audienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/audience-model/$(audienceModelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_audience_model(configured_audience_model_arn)
delete_configured_audience_model(configured_audience_model_arn, params::Dict{String,<:Any})
Deletes the specified configured audience model. You can't delete a configured audience
model if there are any lookalike models that use the configured audience model. If you
delete a configured audience model, it will be removed from any collaborations that it is
associated to.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that you want to delete.
"""
function delete_configured_audience_model(
configuredAudienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/configured-audience-model/$(configuredAudienceModelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_audience_model(
configuredAudienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/configured-audience-model/$(configuredAudienceModelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_configured_audience_model_policy(configured_audience_model_arn)
delete_configured_audience_model_policy(configured_audience_model_arn, params::Dict{String,<:Any})
Deletes the specified configured audience model policy.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model policy that you want to delete.
"""
function delete_configured_audience_model_policy(
configuredAudienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/configured-audience-model/$(configuredAudienceModelArn)/policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_configured_audience_model_policy(
configuredAudienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/configured-audience-model/$(configuredAudienceModelArn)/policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_training_dataset(training_dataset_arn)
delete_training_dataset(training_dataset_arn, params::Dict{String,<:Any})
Specifies a training dataset that you want to delete. You can't delete a training dataset
if there are any audience models that depend on the training dataset. In Clean Rooms ML,
the TrainingDataset is metadata that points to a Glue table, which is read only during
AudienceModel creation. This action deletes the metadata.
# Arguments
- `training_dataset_arn`: The Amazon Resource Name (ARN) of the training dataset that you
want to delete.
"""
function delete_training_dataset(
trainingDatasetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/training-dataset/$(trainingDatasetArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_training_dataset(
trainingDatasetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/training-dataset/$(trainingDatasetArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_audience_generation_job(audience_generation_job_arn)
get_audience_generation_job(audience_generation_job_arn, params::Dict{String,<:Any})
Returns information about an audience generation job.
# Arguments
- `audience_generation_job_arn`: The Amazon Resource Name (ARN) of the audience generation
job that you are interested in.
"""
function get_audience_generation_job(
audienceGenerationJobArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/audience-generation-job/$(audienceGenerationJobArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_audience_generation_job(
audienceGenerationJobArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/audience-generation-job/$(audienceGenerationJobArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_audience_model(audience_model_arn)
get_audience_model(audience_model_arn, params::Dict{String,<:Any})
Returns information about an audience model
# Arguments
- `audience_model_arn`: The Amazon Resource Name (ARN) of the audience model that you are
interested in.
"""
function get_audience_model(
audienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/audience-model/$(audienceModelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_audience_model(
audienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/audience-model/$(audienceModelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_audience_model(configured_audience_model_arn)
get_configured_audience_model(configured_audience_model_arn, params::Dict{String,<:Any})
Returns information about a specified configured audience model.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that you are interested in.
"""
function get_configured_audience_model(
configuredAudienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/configured-audience-model/$(configuredAudienceModelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_audience_model(
configuredAudienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/configured-audience-model/$(configuredAudienceModelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_configured_audience_model_policy(configured_audience_model_arn)
get_configured_audience_model_policy(configured_audience_model_arn, params::Dict{String,<:Any})
Returns information about a configured audience model policy.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that you are interested in.
"""
function get_configured_audience_model_policy(
configuredAudienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/configured-audience-model/$(configuredAudienceModelArn)/policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_configured_audience_model_policy(
configuredAudienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/configured-audience-model/$(configuredAudienceModelArn)/policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_training_dataset(training_dataset_arn)
get_training_dataset(training_dataset_arn, params::Dict{String,<:Any})
Returns information about a training dataset.
# Arguments
- `training_dataset_arn`: The Amazon Resource Name (ARN) of the training dataset that you
are interested in.
"""
function get_training_dataset(
trainingDatasetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/training-dataset/$(trainingDatasetArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_training_dataset(
trainingDatasetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/training-dataset/$(trainingDatasetArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_audience_export_jobs()
list_audience_export_jobs(params::Dict{String,<:Any})
Returns a list of the audience export jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"audienceGenerationJobArn"`: The Amazon Resource Name (ARN) of the audience generation
job that you are interested in.
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_audience_export_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanroomsml(
"GET",
"/audience-export-job";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_audience_export_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/audience-export-job",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_audience_generation_jobs()
list_audience_generation_jobs(params::Dict{String,<:Any})
Returns a list of audience generation jobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"collaborationId"`: The identifier of the collaboration that contains the audience
generation jobs that you are interested in.
- `"configuredAudienceModelArn"`: The Amazon Resource Name (ARN) of the configured audience
model that was used for the audience generation jobs that you are interested in.
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_audience_generation_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanroomsml(
"GET",
"/audience-generation-job";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_audience_generation_jobs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/audience-generation-job",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_audience_models()
list_audience_models(params::Dict{String,<:Any})
Returns a list of audience models.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_audience_models(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanroomsml(
"GET", "/audience-model"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_audience_models(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/audience-model",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_configured_audience_models()
list_configured_audience_models(params::Dict{String,<:Any})
Returns a list of the configured audience models.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_configured_audience_models(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/configured-audience-model";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_configured_audience_models(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/configured-audience-model",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for a provided resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you are interested in.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_training_datasets()
list_training_datasets(params::Dict{String,<:Any})
Returns a list of training datasets.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum size of the results that is returned per call.
- `"nextToken"`: The token value retrieved from a previous call to access the next page of
results.
"""
function list_training_datasets(; aws_config::AbstractAWSConfig=global_aws_config())
return cleanroomsml(
"GET", "/training-dataset"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_training_datasets(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"GET",
"/training-dataset",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_configured_audience_model_policy(configured_audience_model_arn, configured_audience_model_policy)
put_configured_audience_model_policy(configured_audience_model_arn, configured_audience_model_policy, params::Dict{String,<:Any})
Create or update the resource policy for a configured audience model.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that the resource policy will govern.
- `configured_audience_model_policy`: The IAM resource policy.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"policyExistenceCondition"`: Use this to prevent unexpected concurrent modification of
the policy.
- `"previousPolicyHash"`: A cryptographic hash of the contents of the policy used to
prevent unexpected concurrent modification of the policy.
"""
function put_configured_audience_model_policy(
configuredAudienceModelArn,
configuredAudienceModelPolicy;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"PUT",
"/configured-audience-model/$(configuredAudienceModelArn)/policy",
Dict{String,Any}("configuredAudienceModelPolicy" => configuredAudienceModelPolicy);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_configured_audience_model_policy(
configuredAudienceModelArn,
configuredAudienceModelPolicy,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"PUT",
"/configured-audience-model/$(configuredAudienceModelArn)/policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configuredAudienceModelPolicy" => configuredAudienceModelPolicy
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_audience_export_job(audience_generation_job_arn, audience_size, name)
start_audience_export_job(audience_generation_job_arn, audience_size, name, params::Dict{String,<:Any})
Export an audience of a specified size after you have generated an audience.
# Arguments
- `audience_generation_job_arn`: The Amazon Resource Name (ARN) of the audience generation
job that you want to export.
- `audience_size`:
- `name`: The name of the audience export job.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the audience export job.
"""
function start_audience_export_job(
audienceGenerationJobArn,
audienceSize,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/audience-export-job",
Dict{String,Any}(
"audienceGenerationJobArn" => audienceGenerationJobArn,
"audienceSize" => audienceSize,
"name" => name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_audience_export_job(
audienceGenerationJobArn,
audienceSize,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/audience-export-job",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"audienceGenerationJobArn" => audienceGenerationJobArn,
"audienceSize" => audienceSize,
"name" => name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_audience_generation_job(configured_audience_model_arn, name, seed_audience)
start_audience_generation_job(configured_audience_model_arn, name, seed_audience, params::Dict{String,<:Any})
Information necessary to start the audience generation job.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that is used for this audience generation job.
- `name`: The name of the audience generation job.
- `seed_audience`: The seed audience that is used to generate the audience.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"collaborationId"`: The identifier of the collaboration that contains the audience
generation job.
- `"description"`: The description of the audience generation job.
- `"includeSeedInOutput"`: Whether the seed audience is included in the audience generation
output.
- `"tags"`: The optional metadata that you apply to the resource to help you categorize and
organize them. Each tag consists of a key and an optional value, both of which you define.
The following basic restrictions apply to tags: Maximum number of tags per resource - 50.
For each resource, each tag key must be unique, and each tag key can have only one value.
Maximum key length - 128 Unicode characters in UTF-8. Maximum value length - 256
Unicode characters in UTF-8. If your tagging schema is used across multiple services and
resources, remember that other services may have restrictions on allowed characters.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following characters: + - = . _ : / @. Tag keys and values are case sensitive. Do
not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as
it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can
have this prefix. If a tag value has aws as its prefix but the key does not, then Clean
Rooms ML considers it to be a user tag and will count against the limit of 50 tags. Tags
with only the key prefix of aws do not count against your tags per resource limit.
"""
function start_audience_generation_job(
configuredAudienceModelArn,
name,
seedAudience;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/audience-generation-job",
Dict{String,Any}(
"configuredAudienceModelArn" => configuredAudienceModelArn,
"name" => name,
"seedAudience" => seedAudience,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_audience_generation_job(
configuredAudienceModelArn,
name,
seedAudience,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/audience-generation-job",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"configuredAudienceModelArn" => configuredAudienceModelArn,
"name" => name,
"seedAudience" => seedAudience,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds metadata tags to a specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to assign
tags.
- `tags`: The optional metadata that you apply to the resource to help you categorize and
organize them. Each tag consists of a key and an optional value, both of which you define.
The following basic restrictions apply to tags: Maximum number of tags per resource - 50.
For each resource, each tag key must be unique, and each tag key can have only one value.
Maximum key length - 128 Unicode characters in UTF-8. Maximum value length - 256
Unicode characters in UTF-8. If your tagging schema is used across multiple services and
resources, remember that other services may have restrictions on allowed characters.
Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and
the following characters: + - = . _ : / @. Tag keys and values are case sensitive. Do
not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as
it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can
have this prefix. If a tag value has aws as its prefix but the key does not, then Clean
Rooms considers it to be a user tag and will count against the limit of 50 tags. Tags with
only the key prefix of aws do not count against your tags per resource limit.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return cleanroomsml(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes metadata tags from a specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to remove
tags from.
- `tag_keys`: The key values of tags that you want to remove.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_configured_audience_model(configured_audience_model_arn)
update_configured_audience_model(configured_audience_model_arn, params::Dict{String,<:Any})
Provides the information necessary to update a configured audience model. Updates that
impact audience generation jobs take effect when a new job starts, but do not impact
currently running jobs.
# Arguments
- `configured_audience_model_arn`: The Amazon Resource Name (ARN) of the configured
audience model that you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"audienceModelArn"`: The Amazon Resource Name (ARN) of the new audience model that you
want to use.
- `"audienceSizeConfig"`: The new audience size configuration.
- `"description"`: The new description of the configured audience model.
- `"minMatchingSeedSize"`: The minimum number of users from the seed audience that must
match with users in the training data of the audience model.
- `"outputConfig"`: The new output configuration.
- `"sharedAudienceMetrics"`: The new value for whether to share audience metrics.
"""
function update_configured_audience_model(
configuredAudienceModelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cleanroomsml(
"PATCH",
"/configured-audience-model/$(configuredAudienceModelArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_configured_audience_model(
configuredAudienceModelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cleanroomsml(
"PATCH",
"/configured-audience-model/$(configuredAudienceModelArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 20718 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloud9
using AWS.Compat
using AWS.UUIDs
"""
create_environment_ec2(image_id, instance_type, name)
create_environment_ec2(image_id, instance_type, name, params::Dict{String,<:Any})
Creates an Cloud9 development environment, launches an Amazon Elastic Compute Cloud (Amazon
EC2) instance, and then connects from the instance to the environment.
# Arguments
- `image_id`: The identifier for the Amazon Machine Image (AMI) that's used to create the
EC2 instance. To choose an AMI for the instance, you must specify a valid AMI alias or a
valid Amazon EC2 Systems Manager (SSM) path. From December 04, 2023, you will be required
to include the imageId parameter for the CreateEnvironmentEC2 action. This change will be
reflected across all direct methods of communicating with the API, such as Amazon Web
Services SDK, Amazon Web Services CLI and Amazon Web Services CloudFormation. This change
will only affect direct API consumers, and not Cloud9 console users. We recommend using
Amazon Linux 2023 as the AMI to create your environment as it is fully supported. Since
Ubuntu 18.04 has ended standard support as of May 31, 2023, we recommend you choose Ubuntu
22.04. AMI aliases Amazon Linux 2: amazonlinux-2-x86_64 Amazon Linux 2023
(recommended): amazonlinux-2023-x86_64 Ubuntu 18.04: ubuntu-18.04-x86_64 Ubuntu
22.04: ubuntu-22.04-x86_64 SSM paths Amazon Linux 2:
resolve:ssm:/aws/service/cloud9/amis/amazonlinux-2-x86_64 Amazon Linux 2023
(recommended): resolve:ssm:/aws/service/cloud9/amis/amazonlinux-2023-x86_64 Ubuntu
18.04: resolve:ssm:/aws/service/cloud9/amis/ubuntu-18.04-x86_64 Ubuntu 22.04:
resolve:ssm:/aws/service/cloud9/amis/ubuntu-22.04-x86_64
- `instance_type`: The type of instance to connect to the environment (for example,
t2.micro).
- `name`: The name of the environment to create. This name is visible to other IAM users in
the same Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"automaticStopTimeMinutes"`: The number of minutes until the running instance is shut
down after the environment has last been used.
- `"clientRequestToken"`: A unique, case-sensitive string that helps Cloud9 to ensure this
operation completes no more than one time. For more information, see Client Tokens in the
Amazon EC2 API Reference.
- `"connectionType"`: The connection type used for connecting to an Amazon EC2 environment.
Valid values are CONNECT_SSH (default) and CONNECT_SSM (connected through Amazon EC2
Systems Manager). For more information, see Accessing no-ingress EC2 instances with Amazon
EC2 Systems Manager in the Cloud9 User Guide.
- `"description"`: The description of the environment to create.
- `"dryRun"`: Checks whether you have the required permissions for the action, without
actually making the request, and provides an error response. If you have the required
permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation.
- `"ownerArn"`: The Amazon Resource Name (ARN) of the environment owner. This ARN can be
the ARN of any IAM principal. If this value is not specified, the ARN defaults to this
environment's creator.
- `"subnetId"`: The ID of the subnet in Amazon VPC that Cloud9 will use to communicate with
the Amazon EC2 instance.
- `"tags"`: An array of key-value pairs that will be associated with the new Cloud9
development environment.
"""
function create_environment_ec2(
imageId, instanceType, name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"CreateEnvironmentEC2",
Dict{String,Any}(
"imageId" => imageId, "instanceType" => instanceType, "name" => name
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_environment_ec2(
imageId,
instanceType,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"CreateEnvironmentEC2",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"imageId" => imageId, "instanceType" => instanceType, "name" => name
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_environment_membership(environment_id, permissions, user_arn)
create_environment_membership(environment_id, permissions, user_arn, params::Dict{String,<:Any})
Adds an environment member to an Cloud9 development environment.
# Arguments
- `environment_id`: The ID of the environment that contains the environment member you want
to add.
- `permissions`: The type of environment member permissions you want to associate with this
environment member. Available values include: read-only: Has read-only access to the
environment. read-write: Has read-write access to the environment.
- `user_arn`: The Amazon Resource Name (ARN) of the environment member you want to add.
"""
function create_environment_membership(
environmentId, permissions, userArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"CreateEnvironmentMembership",
Dict{String,Any}(
"environmentId" => environmentId,
"permissions" => permissions,
"userArn" => userArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_environment_membership(
environmentId,
permissions,
userArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"CreateEnvironmentMembership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"environmentId" => environmentId,
"permissions" => permissions,
"userArn" => userArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_environment(environment_id)
delete_environment(environment_id, params::Dict{String,<:Any})
Deletes an Cloud9 development environment. If an Amazon EC2 instance is connected to the
environment, also terminates the instance.
# Arguments
- `environment_id`: The ID of the environment to delete.
"""
function delete_environment(
environmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DeleteEnvironment",
Dict{String,Any}("environmentId" => environmentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_environment(
environmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"DeleteEnvironment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("environmentId" => environmentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_environment_membership(environment_id, user_arn)
delete_environment_membership(environment_id, user_arn, params::Dict{String,<:Any})
Deletes an environment member from a development environment.
# Arguments
- `environment_id`: The ID of the environment to delete the environment member from.
- `user_arn`: The Amazon Resource Name (ARN) of the environment member to delete from the
environment.
"""
function delete_environment_membership(
environmentId, userArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DeleteEnvironmentMembership",
Dict{String,Any}("environmentId" => environmentId, "userArn" => userArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_environment_membership(
environmentId,
userArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"DeleteEnvironmentMembership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("environmentId" => environmentId, "userArn" => userArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_environment_memberships()
describe_environment_memberships(params::Dict{String,<:Any})
Gets information about environment members for an Cloud9 development environment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"environmentId"`: The ID of the environment to get environment member information about.
- `"maxResults"`: The maximum number of environment members to get information about.
- `"nextToken"`: During a previous call, if there are more than 25 items in the list, only
the first 25 items are returned, along with a unique string called a next token. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
- `"permissions"`: The type of environment member permissions to get information about.
Available values include: owner: Owns the environment. read-only: Has read-only
access to the environment. read-write: Has read-write access to the environment. If no
value is specified, information about all environment members are returned.
- `"userArn"`: The Amazon Resource Name (ARN) of an individual environment member to get
information about. If no value is specified, information about all environment members are
returned.
"""
function describe_environment_memberships(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DescribeEnvironmentMemberships";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_environment_memberships(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DescribeEnvironmentMemberships",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_environment_status(environment_id)
describe_environment_status(environment_id, params::Dict{String,<:Any})
Gets status information for an Cloud9 development environment.
# Arguments
- `environment_id`: The ID of the environment to get status information about.
"""
function describe_environment_status(
environmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DescribeEnvironmentStatus",
Dict{String,Any}("environmentId" => environmentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_environment_status(
environmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"DescribeEnvironmentStatus",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("environmentId" => environmentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_environments(environment_ids)
describe_environments(environment_ids, params::Dict{String,<:Any})
Gets information about Cloud9 development environments.
# Arguments
- `environment_ids`: The IDs of individual environments to get information about.
"""
function describe_environments(
environmentIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"DescribeEnvironments",
Dict{String,Any}("environmentIds" => environmentIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_environments(
environmentIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"DescribeEnvironments",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("environmentIds" => environmentIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_environments()
list_environments(params::Dict{String,<:Any})
Gets a list of Cloud9 development environment identifiers.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of environments to get identifiers for.
- `"nextToken"`: During a previous call, if there are more than 25 items in the list, only
the first 25 items are returned, along with a unique string called a next token. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
"""
function list_environments(; aws_config::AbstractAWSConfig=global_aws_config())
return cloud9(
"ListEnvironments"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_environments(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"ListEnvironments", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Gets a list of the tags associated with an Cloud9 development environment.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the Cloud9 development environment to
get the tags for.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds tags to an Cloud9 development environment. Tags that you add to an Cloud9 environment
by using this method will NOT be automatically propagated to underlying resources.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the Cloud9 development environment to
add tags to.
- `tags`: The list of tags to add to the given Cloud9 development environment.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return cloud9(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from an Cloud9 development environment.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the Cloud9 development environment to
remove tags from.
- `tag_keys`: The tag names of the tags to remove from the given Cloud9 development
environment.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_environment(environment_id)
update_environment(environment_id, params::Dict{String,<:Any})
Changes the settings of an existing Cloud9 development environment.
# Arguments
- `environment_id`: The ID of the environment to change settings.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: Any new or replacement description for the environment.
- `"managedCredentialsAction"`: Allows the environment owner to turn on or turn off the
Amazon Web Services managed temporary credentials for an Cloud9 environment by using one of
the following values: ENABLE DISABLE Only the environment owner can change the
status of managed temporary credentials. An AccessDeniedException is thrown if an attempt
to turn on or turn off managed temporary credentials is made by an account that's not the
environment owner.
- `"name"`: A replacement name for the environment.
"""
function update_environment(
environmentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"UpdateEnvironment",
Dict{String,Any}("environmentId" => environmentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_environment(
environmentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"UpdateEnvironment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("environmentId" => environmentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_environment_membership(environment_id, permissions, user_arn)
update_environment_membership(environment_id, permissions, user_arn, params::Dict{String,<:Any})
Changes the settings of an existing environment member for an Cloud9 development
environment.
# Arguments
- `environment_id`: The ID of the environment for the environment member whose settings you
want to change.
- `permissions`: The replacement type of environment member permissions you want to
associate with this environment member. Available values include: read-only: Has
read-only access to the environment. read-write: Has read-write access to the
environment.
- `user_arn`: The Amazon Resource Name (ARN) of the environment member whose settings you
want to change.
"""
function update_environment_membership(
environmentId, permissions, userArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloud9(
"UpdateEnvironmentMembership",
Dict{String,Any}(
"environmentId" => environmentId,
"permissions" => permissions,
"userArn" => userArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_environment_membership(
environmentId,
permissions,
userArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloud9(
"UpdateEnvironmentMembership",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"environmentId" => environmentId,
"permissions" => permissions,
"userArn" => userArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 22264 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudcontrol
using AWS.Compat
using AWS.UUIDs
"""
cancel_resource_request(request_token)
cancel_resource_request(request_token, params::Dict{String,<:Any})
Cancels the specified resource operation request. For more information, see Canceling
resource operation requests in the Amazon Web Services Cloud Control API User Guide. Only
resource operations requests with a status of PENDING or IN_PROGRESS can be canceled.
# Arguments
- `request_token`: The RequestToken of the ProgressEvent object returned by the resource
operation request.
"""
function cancel_resource_request(
RequestToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"CancelResourceRequest",
Dict{String,Any}("RequestToken" => RequestToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_resource_request(
RequestToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"CancelResourceRequest",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RequestToken" => RequestToken), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_resource(desired_state, type_name)
create_resource(desired_state, type_name, params::Dict{String,<:Any})
Creates the specified resource. For more information, see Creating a resource in the Amazon
Web Services Cloud Control API User Guide. After you have initiated a resource creation
request, you can monitor the progress of your request by calling GetResourceRequestStatus
using the RequestToken of the ProgressEvent type returned by CreateResource.
# Arguments
- `desired_state`: Structured data format representing the desired state of the resource,
consisting of that resource's properties and their desired values. Cloud Control API
currently supports JSON as a structured data format. Specify the desired state as one of
the following: A JSON blob A local path containing the desired state in JSON data
format For more information, see Composing the desired state of the resource in the
Amazon Web Services Cloud Control API User Guide. For more information about the properties
of a specific resource, refer to the related topic for the resource in the Resource and
property types reference in the CloudFormation Users Guide.
- `type_name`: The name of the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique identifier to ensure the idempotency of the resource request.
As a best practice, specify this token to ensure idempotency, so that Amazon Web Services
Cloud Control API can accurately distinguish between request retries and new resource
requests. You might retry a resource request to ensure that it was successfully received. A
client token is valid for 36 hours once used. After that, a resource request with the same
client token is treated as a new request. If you do not specify a client token, one is
generated for inclusion in the request. For more information, see Ensuring resource
operation requests are unique in the Amazon Web Services Cloud Control API User Guide.
- `"RoleArn"`: The Amazon Resource Name (ARN) of the Identity and Access Management (IAM)
role for Cloud Control API to use when performing this resource operation. The role
specified must have the permissions required for this operation. The necessary permissions
for each event handler are defined in the handlers section of the resource type
definition schema. If you do not specify a role, Cloud Control API uses a temporary session
created using your Amazon Web Services user credentials. For more information, see
Specifying credentials in the Amazon Web Services Cloud Control API User Guide.
- `"TypeVersionId"`: For private resource types, the type version to use in this resource
operation. If you do not specify a resource version, CloudFormation uses the default
version.
"""
function create_resource(
DesiredState, TypeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"CreateResource",
Dict{String,Any}(
"DesiredState" => DesiredState,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_resource(
DesiredState,
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"CreateResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DesiredState" => DesiredState,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resource(identifier, type_name)
delete_resource(identifier, type_name, params::Dict{String,<:Any})
Deletes the specified resource. For details, see Deleting a resource in the Amazon Web
Services Cloud Control API User Guide. After you have initiated a resource deletion
request, you can monitor the progress of your request by calling GetResourceRequestStatus
using the RequestToken of the ProgressEvent returned by DeleteResource.
# Arguments
- `identifier`: The identifier for the resource. You can specify the primary identifier, or
any secondary identifier defined for the resource type in its resource schema. You can only
specify one identifier. Primary identifiers can be specified as a string or JSON; secondary
identifiers must be specified as JSON. For compound primary identifiers (that is, one that
consists of multiple resource properties strung together), to specify the primary
identifier as a string, list the property values in the order they are specified in the
primary identifier definition, separated by |. For more information, see Identifying
resources in the Amazon Web Services Cloud Control API User Guide.
- `type_name`: The name of the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique identifier to ensure the idempotency of the resource request.
As a best practice, specify this token to ensure idempotency, so that Amazon Web Services
Cloud Control API can accurately distinguish between request retries and new resource
requests. You might retry a resource request to ensure that it was successfully received. A
client token is valid for 36 hours once used. After that, a resource request with the same
client token is treated as a new request. If you do not specify a client token, one is
generated for inclusion in the request. For more information, see Ensuring resource
operation requests are unique in the Amazon Web Services Cloud Control API User Guide.
- `"RoleArn"`: The Amazon Resource Name (ARN) of the Identity and Access Management (IAM)
role for Cloud Control API to use when performing this resource operation. The role
specified must have the permissions required for this operation. The necessary permissions
for each event handler are defined in the handlers section of the resource type
definition schema. If you do not specify a role, Cloud Control API uses a temporary session
created using your Amazon Web Services user credentials. For more information, see
Specifying credentials in the Amazon Web Services Cloud Control API User Guide.
- `"TypeVersionId"`: For private resource types, the type version to use in this resource
operation. If you do not specify a resource version, CloudFormation uses the default
version.
"""
function delete_resource(
Identifier, TypeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"DeleteResource",
Dict{String,Any}(
"Identifier" => Identifier,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resource(
Identifier,
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"DeleteResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Identifier" => Identifier,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource(identifier, type_name)
get_resource(identifier, type_name, params::Dict{String,<:Any})
Returns information about the current state of the specified resource. For details, see
Reading a resource's current state. You can use this action to return information about an
existing resource in your account and Amazon Web Services Region, whether those resources
were provisioned using Cloud Control API.
# Arguments
- `identifier`: The identifier for the resource. You can specify the primary identifier, or
any secondary identifier defined for the resource type in its resource schema. You can only
specify one identifier. Primary identifiers can be specified as a string or JSON; secondary
identifiers must be specified as JSON. For compound primary identifiers (that is, one that
consists of multiple resource properties strung together), to specify the primary
identifier as a string, list the property values in the order they are specified in the
primary identifier definition, separated by |. For more information, see Identifying
resources in the Amazon Web Services Cloud Control API User Guide.
- `type_name`: The name of the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RoleArn"`: The Amazon Resource Name (ARN) of the Identity and Access Management (IAM)
role for Cloud Control API to use when performing this resource operation. The role
specified must have the permissions required for this operation. The necessary permissions
for each event handler are defined in the handlers section of the resource type
definition schema. If you do not specify a role, Cloud Control API uses a temporary session
created using your Amazon Web Services user credentials. For more information, see
Specifying credentials in the Amazon Web Services Cloud Control API User Guide.
- `"TypeVersionId"`: For private resource types, the type version to use in this resource
operation. If you do not specify a resource version, CloudFormation uses the default
version.
"""
function get_resource(
Identifier, TypeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"GetResource",
Dict{String,Any}("Identifier" => Identifier, "TypeName" => TypeName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource(
Identifier,
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"GetResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Identifier" => Identifier, "TypeName" => TypeName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource_request_status(request_token)
get_resource_request_status(request_token, params::Dict{String,<:Any})
Returns the current status of a resource operation request. For more information, see
Tracking the progress of resource operation requests in the Amazon Web Services Cloud
Control API User Guide.
# Arguments
- `request_token`: A unique token used to track the progress of the resource operation
request. Request tokens are included in the ProgressEvent type returned by a resource
operation request.
"""
function get_resource_request_status(
RequestToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"GetResourceRequestStatus",
Dict{String,Any}("RequestToken" => RequestToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource_request_status(
RequestToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"GetResourceRequestStatus",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RequestToken" => RequestToken), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resource_requests()
list_resource_requests(params::Dict{String,<:Any})
Returns existing resource operation requests. This includes requests of all status types.
For more information, see Listing active resource operation requests in the Amazon Web
Services Cloud Control API User Guide. Resource operation requests expire after 7 days.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results. The
default is 20.
- `"NextToken"`: If the previous paginated request didn't return all of the remaining
results, the response object's NextToken parameter value is set to a token. To retrieve the
next set of results, call this action again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"ResourceRequestStatusFilter"`: The filter criteria to apply to the requests returned.
"""
function list_resource_requests(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudcontrol(
"ListResourceRequests"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_resource_requests(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"ListResourceRequests",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resources(type_name)
list_resources(type_name, params::Dict{String,<:Any})
Returns information about the specified resources. For more information, see Discovering
resources in the Amazon Web Services Cloud Control API User Guide. You can use this action
to return information about existing resources in your account and Amazon Web Services
Region, whether those resources were provisioned using Cloud Control API.
# Arguments
- `type_name`: The name of the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Reserved.
- `"NextToken"`: If the previous paginated request didn't return all of the remaining
results, the response object's NextToken parameter value is set to a token. To retrieve the
next set of results, call this action again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"ResourceModel"`: The resource model to use to select the resources to return.
- `"RoleArn"`: The Amazon Resource Name (ARN) of the Identity and Access Management (IAM)
role for Cloud Control API to use when performing this resource operation. The role
specified must have the permissions required for this operation. The necessary permissions
for each event handler are defined in the handlers section of the resource type
definition schema. If you do not specify a role, Cloud Control API uses a temporary session
created using your Amazon Web Services user credentials. For more information, see
Specifying credentials in the Amazon Web Services Cloud Control API User Guide.
- `"TypeVersionId"`: For private resource types, the type version to use in this resource
operation. If you do not specify a resource version, CloudFormation uses the default
version.
"""
function list_resources(TypeName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudcontrol(
"ListResources",
Dict{String,Any}("TypeName" => TypeName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resources(
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"ListResources",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TypeName" => TypeName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_resource(identifier, patch_document, type_name)
update_resource(identifier, patch_document, type_name, params::Dict{String,<:Any})
Updates the specified property values in the resource. You specify your resource property
updates as a list of patch operations contained in a JSON patch document that adheres to
the RFC 6902 - JavaScript Object Notation (JSON) Patch standard. For details on how Cloud
Control API performs resource update operations, see Updating a resource in the Amazon Web
Services Cloud Control API User Guide. After you have initiated a resource update request,
you can monitor the progress of your request by calling GetResourceRequestStatus using the
RequestToken of the ProgressEvent returned by UpdateResource. For more information about
the properties of a specific resource, refer to the related topic for the resource in the
Resource and property types reference in the CloudFormation Users Guide.
# Arguments
- `identifier`: The identifier for the resource. You can specify the primary identifier, or
any secondary identifier defined for the resource type in its resource schema. You can only
specify one identifier. Primary identifiers can be specified as a string or JSON; secondary
identifiers must be specified as JSON. For compound primary identifiers (that is, one that
consists of multiple resource properties strung together), to specify the primary
identifier as a string, list the property values in the order they are specified in the
primary identifier definition, separated by |. For more information, see Identifying
resources in the Amazon Web Services Cloud Control API User Guide.
- `patch_document`: A JavaScript Object Notation (JSON) document listing the patch
operations that represent the updates to apply to the current resource properties. For
details, see Composing the patch document in the Amazon Web Services Cloud Control API User
Guide.
- `type_name`: The name of the resource type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A unique identifier to ensure the idempotency of the resource request.
As a best practice, specify this token to ensure idempotency, so that Amazon Web Services
Cloud Control API can accurately distinguish between request retries and new resource
requests. You might retry a resource request to ensure that it was successfully received. A
client token is valid for 36 hours once used. After that, a resource request with the same
client token is treated as a new request. If you do not specify a client token, one is
generated for inclusion in the request. For more information, see Ensuring resource
operation requests are unique in the Amazon Web Services Cloud Control API User Guide.
- `"RoleArn"`: The Amazon Resource Name (ARN) of the Identity and Access Management (IAM)
role for Cloud Control API to use when performing this resource operation. The role
specified must have the permissions required for this operation. The necessary permissions
for each event handler are defined in the handlers section of the resource type
definition schema. If you do not specify a role, Cloud Control API uses a temporary session
created using your Amazon Web Services user credentials. For more information, see
Specifying credentials in the Amazon Web Services Cloud Control API User Guide.
- `"TypeVersionId"`: For private resource types, the type version to use in this resource
operation. If you do not specify a resource version, CloudFormation uses the default
version.
"""
function update_resource(
Identifier, PatchDocument, TypeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudcontrol(
"UpdateResource",
Dict{String,Any}(
"Identifier" => Identifier,
"PatchDocument" => PatchDocument,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_resource(
Identifier,
PatchDocument,
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudcontrol(
"UpdateResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Identifier" => Identifier,
"PatchDocument" => PatchDocument,
"TypeName" => TypeName,
"ClientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 120723 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: clouddirectory
using AWS.Compat
using AWS.UUIDs
"""
add_facet_to_object(object_reference, schema_facet, x-amz-data-partition)
add_facet_to_object(object_reference, schema_facet, x-amz-data-partition, params::Dict{String,<:Any})
Adds a new Facet to an object. An object can have more than one facet applied on it.
# Arguments
- `object_reference`: A reference to the object you are adding the specified facet to.
- `schema_facet`: Identifiers for the facet that you are adding to the object. See
SchemaFacet for details.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ObjectAttributeList"`: Attributes on the facet that you are adding to the object.
"""
function add_facet_to_object(
ObjectReference,
SchemaFacet,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/facets",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_facet_to_object(
ObjectReference,
SchemaFacet,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/facets",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
apply_schema(published_schema_arn, x-amz-data-partition)
apply_schema(published_schema_arn, x-amz-data-partition, params::Dict{String,<:Any})
Copies the input published schema, at the specified version, into the Directory with the
same name and version as that of the published schema.
# Arguments
- `published_schema_arn`: Published schema Amazon Resource Name (ARN) that needs to be
copied. For more information, see arns.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory into which the schema is copied. For more information, see arns.
"""
function apply_schema(
PublishedSchemaArn,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/apply",
Dict{String,Any}(
"PublishedSchemaArn" => PublishedSchemaArn,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function apply_schema(
PublishedSchemaArn,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/apply",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PublishedSchemaArn" => PublishedSchemaArn,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_object(child_reference, link_name, parent_reference, x-amz-data-partition)
attach_object(child_reference, link_name, parent_reference, x-amz-data-partition, params::Dict{String,<:Any})
Attaches an existing object to another object. An object can be accessed in two ways:
Using the path Using ObjectIdentifier
# Arguments
- `child_reference`: The child object reference to be attached to the object.
- `link_name`: The link name with which the child object is attached to the parent.
- `parent_reference`: The parent object reference.
- `x-amz-data-partition`: Amazon Resource Name (ARN) that is associated with the Directory
where both objects reside. For more information, see arns.
"""
function attach_object(
ChildReference,
LinkName,
ParentReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/attach",
Dict{String,Any}(
"ChildReference" => ChildReference,
"LinkName" => LinkName,
"ParentReference" => ParentReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_object(
ChildReference,
LinkName,
ParentReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/attach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChildReference" => ChildReference,
"LinkName" => LinkName,
"ParentReference" => ParentReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_policy(object_reference, policy_reference, x-amz-data-partition)
attach_policy(object_reference, policy_reference, x-amz-data-partition, params::Dict{String,<:Any})
Attaches a policy object to a regular object. An object can have a limited number of
attached policies.
# Arguments
- `object_reference`: The reference that identifies the object to which the policy will be
attached.
- `policy_reference`: The reference that is associated with the policy object.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where both objects reside. For more information, see arns.
"""
function attach_policy(
ObjectReference,
PolicyReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/policy/attach",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"PolicyReference" => PolicyReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_policy(
ObjectReference,
PolicyReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/policy/attach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"PolicyReference" => PolicyReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_to_index(index_reference, target_reference, x-amz-data-partition)
attach_to_index(index_reference, target_reference, x-amz-data-partition, params::Dict{String,<:Any})
Attaches the specified object to the specified index.
# Arguments
- `index_reference`: A reference to the index that you are attaching the object to.
- `target_reference`: A reference to the object that you are attaching to the index.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory where the object
and index exist.
"""
function attach_to_index(
IndexReference,
TargetReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index/attach",
Dict{String,Any}(
"IndexReference" => IndexReference,
"TargetReference" => TargetReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_to_index(
IndexReference,
TargetReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index/attach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IndexReference" => IndexReference,
"TargetReference" => TargetReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
attach_typed_link(attributes, source_object_reference, target_object_reference, typed_link_facet, x-amz-data-partition)
attach_typed_link(attributes, source_object_reference, target_object_reference, typed_link_facet, x-amz-data-partition, params::Dict{String,<:Any})
Attaches a typed link to a specified source and target object. For more information, see
Typed Links.
# Arguments
- `attributes`: A set of attributes that are associated with the typed link.
- `source_object_reference`: Identifies the source object that the typed link will attach
to.
- `target_object_reference`: Identifies the target object that the typed link will attach
to.
- `typed_link_facet`: Identifies the typed link facet that is associated with the typed
link.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory where you want to
attach the typed link.
"""
function attach_typed_link(
Attributes,
SourceObjectReference,
TargetObjectReference,
TypedLinkFacet,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/attach",
Dict{String,Any}(
"Attributes" => Attributes,
"SourceObjectReference" => SourceObjectReference,
"TargetObjectReference" => TargetObjectReference,
"TypedLinkFacet" => TypedLinkFacet,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function attach_typed_link(
Attributes,
SourceObjectReference,
TargetObjectReference,
TypedLinkFacet,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/attach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Attributes" => Attributes,
"SourceObjectReference" => SourceObjectReference,
"TargetObjectReference" => TargetObjectReference,
"TypedLinkFacet" => TypedLinkFacet,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_read(operations, x-amz-data-partition)
batch_read(operations, x-amz-data-partition, params::Dict{String,<:Any})
Performs all the read operations in a batch.
# Arguments
- `operations`: A list of operations that are part of the batch.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function batch_read(
Operations, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/batchread",
Dict{String,Any}(
"Operations" => Operations,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_read(
Operations,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/batchread",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Operations" => Operations,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_write(operations, x-amz-data-partition)
batch_write(operations, x-amz-data-partition, params::Dict{String,<:Any})
Performs all the write operations in a batch. Either all the operations succeed or none.
# Arguments
- `operations`: A list of operations that are part of the batch.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory. For more information, see arns.
"""
function batch_write(
Operations, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/batchwrite",
Dict{String,Any}(
"Operations" => Operations,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_write(
Operations,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/batchwrite",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Operations" => Operations,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_directory(name, x-amz-data-partition)
create_directory(name, x-amz-data-partition, params::Dict{String,<:Any})
Creates a Directory by copying the published schema into the directory. A directory cannot
be created without a schema. You can also quickly create a directory using a managed
schema, called the QuickStartSchema. For more information, see Managed Schema in the Amazon
Cloud Directory Developer Guide.
# Arguments
- `name`: The name of the Directory. Should be unique per account, per region.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the published schema that will
be copied into the data Directory. For more information, see arns.
"""
function create_directory(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/create",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_directory(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/create",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_facet(name, x-amz-data-partition)
create_facet(name, x-amz-data-partition, params::Dict{String,<:Any})
Creates a new Facet in a schema. Facet creation is allowed only in development or applied
schemas.
# Arguments
- `name`: The name of the Facet, which is unique for a given schema.
- `x-amz-data-partition`: The schema ARN in which the new Facet will be created. For more
information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Attributes"`: The attributes that are associated with the Facet.
- `"FacetStyle"`: There are two different styles that you can define on any given facet,
Static and Dynamic. For static facets, all attributes must be defined in the schema. For
dynamic facets, attributes can be defined during data plane operations.
- `"ObjectType"`: Specifies whether a given object created from this facet is of type node,
leaf node, policy or index. Node: Can have multiple children but one parent. Leaf
node: Cannot have children but can have multiple parents. Policy: Allows you to store a
policy document and policy type. For more information, see Policies. Index: Can be
created with the Index API.
"""
function create_facet(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet/create",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_facet(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet/create",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_index(is_unique, ordered_indexed_attribute_list, x-amz-data-partition)
create_index(is_unique, ordered_indexed_attribute_list, x-amz-data-partition, params::Dict{String,<:Any})
Creates an index object. See Indexing and search for more information.
# Arguments
- `is_unique`: Indicates whether the attribute that is being indexed has unique values or
not.
- `ordered_indexed_attribute_list`: Specifies the attributes that should be indexed on.
Currently only a single attribute is supported.
- `x-amz-data-partition`: The ARN of the directory where the index should be created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LinkName"`: The name of the link between the parent object and the index object.
- `"ParentReference"`: A reference to the parent object that contains the index object.
"""
function create_index(
IsUnique,
OrderedIndexedAttributeList,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index",
Dict{String,Any}(
"IsUnique" => IsUnique,
"OrderedIndexedAttributeList" => OrderedIndexedAttributeList,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_index(
IsUnique,
OrderedIndexedAttributeList,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IsUnique" => IsUnique,
"OrderedIndexedAttributeList" => OrderedIndexedAttributeList,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_object(schema_facets, x-amz-data-partition)
create_object(schema_facets, x-amz-data-partition, params::Dict{String,<:Any})
Creates an object in a Directory. Additionally attaches the object to a parent, if a parent
reference and LinkName is specified. An object is simply a collection of Facet attributes.
You can also use this API call to create a policy object, if the facet from which you
create the object is a policy facet.
# Arguments
- `schema_facets`: A list of schema facets to be associated with the object. Do not provide
minor version components. See SchemaFacet for details.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory in which the object will be created. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LinkName"`: The name of link that is used to attach this object to a parent.
- `"ObjectAttributeList"`: The attribute map whose attribute ARN contains the key and
attribute value as the map value.
- `"ParentReference"`: If specified, the parent reference to which this object will be
attached.
"""
function create_object(
SchemaFacets, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object",
Dict{String,Any}(
"SchemaFacets" => SchemaFacets,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_object(
SchemaFacets,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"SchemaFacets" => SchemaFacets,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_schema(name)
create_schema(name, params::Dict{String,<:Any})
Creates a new schema in a development state. A schema can exist in three phases:
Development: This is a mutable phase of the schema. All new schemas are in the development
phase. Once the schema is finalized, it can be published. Published: Published schemas
are immutable and have a version associated with them. Applied: Applied schemas are
mutable in a way that allows you to add new schema facets. You can also add new,
nonrequired attributes to existing schema facets. You can apply only published schemas to
directories.
# Arguments
- `name`: The name that is associated with the schema. This is unique to each account and
in each region.
"""
function create_schema(Name; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/create",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_schema(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/create",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_typed_link_facet(facet, x-amz-data-partition)
create_typed_link_facet(facet, x-amz-data-partition, params::Dict{String,<:Any})
Creates a TypedLinkFacet. For more information, see Typed Links.
# Arguments
- `facet`: Facet structure that is associated with the typed link facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
"""
function create_typed_link_facet(
Facet, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet/create",
Dict{String,Any}(
"Facet" => Facet,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_typed_link_facet(
Facet,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet/create",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Facet" => Facet,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_directory(x-amz-data-partition)
delete_directory(x-amz-data-partition, params::Dict{String,<:Any})
Deletes a directory. Only disabled directories can be deleted. A deleted directory cannot
be undone. Exercise extreme caution when deleting directories.
# Arguments
- `x-amz-data-partition`: The ARN of the directory to delete.
"""
function delete_directory(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_directory(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_facet(name, x-amz-data-partition)
delete_facet(name, x-amz-data-partition, params::Dict{String,<:Any})
Deletes a given Facet. All attributes and Rules that are associated with the facet will be
deleted. Only development schema facets are allowed deletion.
# Arguments
- `name`: The name of the facet to delete.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the Facet.
For more information, see arns.
"""
function delete_facet(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet/delete",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_facet(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet/delete",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_object(object_reference, x-amz-data-partition)
delete_object(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Deletes an object and its associated attributes. Only objects with no children and no
parents can be deleted. The maximum number of attributes that can be deleted during an
object deletion is 30. For more information, see Amazon Cloud Directory Limits.
# Arguments
- `object_reference`: A reference that identifies the object.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
"""
function delete_object(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/delete",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_object(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/delete",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_schema(x-amz-data-partition)
delete_schema(x-amz-data-partition, params::Dict{String,<:Any})
Deletes a given schema. Schemas in a development and published state can only be deleted.
# Arguments
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the development schema. For
more information, see arns.
"""
function delete_schema(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_schema(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_typed_link_facet(name, x-amz-data-partition)
delete_typed_link_facet(name, x-amz-data-partition, params::Dict{String,<:Any})
Deletes a TypedLinkFacet. For more information, see Typed Links.
# Arguments
- `name`: The unique name of the typed link facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
"""
function delete_typed_link_facet(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet/delete",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_typed_link_facet(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet/delete",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_from_index(index_reference, target_reference, x-amz-data-partition)
detach_from_index(index_reference, target_reference, x-amz-data-partition, params::Dict{String,<:Any})
Detaches the specified object from the specified index.
# Arguments
- `index_reference`: A reference to the index object.
- `target_reference`: A reference to the object being detached from the index.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory the index and
object exist in.
"""
function detach_from_index(
IndexReference,
TargetReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index/detach",
Dict{String,Any}(
"IndexReference" => IndexReference,
"TargetReference" => TargetReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_from_index(
IndexReference,
TargetReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/index/detach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IndexReference" => IndexReference,
"TargetReference" => TargetReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_object(link_name, parent_reference, x-amz-data-partition)
detach_object(link_name, parent_reference, x-amz-data-partition, params::Dict{String,<:Any})
Detaches a given object from the parent object. The object that is to be detached from the
parent is specified by the link name.
# Arguments
- `link_name`: The link name associated with the object that needs to be detached.
- `parent_reference`: The parent reference from which the object with the specified link
name is detached.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where objects reside. For more information, see arns.
"""
function detach_object(
LinkName,
ParentReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/detach",
Dict{String,Any}(
"LinkName" => LinkName,
"ParentReference" => ParentReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_object(
LinkName,
ParentReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/detach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LinkName" => LinkName,
"ParentReference" => ParentReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_policy(object_reference, policy_reference, x-amz-data-partition)
detach_policy(object_reference, policy_reference, x-amz-data-partition, params::Dict{String,<:Any})
Detaches a policy from an object.
# Arguments
- `object_reference`: Reference that identifies the object whose policy object will be
detached.
- `policy_reference`: Reference that identifies the policy object.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where both objects reside. For more information, see arns.
"""
function detach_policy(
ObjectReference,
PolicyReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/policy/detach",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"PolicyReference" => PolicyReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_policy(
ObjectReference,
PolicyReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/policy/detach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"PolicyReference" => PolicyReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detach_typed_link(typed_link_specifier, x-amz-data-partition)
detach_typed_link(typed_link_specifier, x-amz-data-partition, params::Dict{String,<:Any})
Detaches a typed link from a specified source and target object. For more information, see
Typed Links.
# Arguments
- `typed_link_specifier`: Used to accept a typed link specifier as input.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory where you want to
detach the typed link.
"""
function detach_typed_link(
TypedLinkSpecifier,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/detach",
Dict{String,Any}(
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detach_typed_link(
TypedLinkSpecifier,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/detach",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_directory(x-amz-data-partition)
disable_directory(x-amz-data-partition, params::Dict{String,<:Any})
Disables the specified directory. Disabled directories cannot be read or written to. Only
enabled directories can be disabled. Disabled directories may be reenabled.
# Arguments
- `x-amz-data-partition`: The ARN of the directory to disable.
"""
function disable_directory(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/disable",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_directory(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/disable",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_directory(x-amz-data-partition)
enable_directory(x-amz-data-partition, params::Dict{String,<:Any})
Enables the specified directory. Only disabled directories can be enabled. Once enabled,
the directory can then be read and written to.
# Arguments
- `x-amz-data-partition`: The ARN of the directory to enable.
"""
function enable_directory(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/enable",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_directory(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/directory/enable",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_applied_schema_version(schema_arn)
get_applied_schema_version(schema_arn, params::Dict{String,<:Any})
Returns current applied schema version ARN, including the minor version in use.
# Arguments
- `schema_arn`: The ARN of the applied schema.
"""
function get_applied_schema_version(
SchemaArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/getappliedschema",
Dict{String,Any}("SchemaArn" => SchemaArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_applied_schema_version(
SchemaArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/getappliedschema",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("SchemaArn" => SchemaArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_directory(x-amz-data-partition)
get_directory(x-amz-data-partition, params::Dict{String,<:Any})
Retrieves metadata about a directory.
# Arguments
- `x-amz-data-partition`: The ARN of the directory.
"""
function get_directory(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/directory/get",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_directory(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/directory/get",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_facet(name, x-amz-data-partition)
get_facet(name, x-amz-data-partition, params::Dict{String,<:Any})
Gets details of the Facet, such as facet name, attributes, Rules, or ObjectType. You can
call this on all kinds of schema facets -- published, development, or applied.
# Arguments
- `name`: The name of the facet to retrieve.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the Facet.
For more information, see arns.
"""
function get_facet(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_facet(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_link_attributes(attribute_names, typed_link_specifier, x-amz-data-partition)
get_link_attributes(attribute_names, typed_link_specifier, x-amz-data-partition, params::Dict{String,<:Any})
Retrieves attributes that are associated with a typed link.
# Arguments
- `attribute_names`: A list of attribute names whose values will be retrieved.
- `typed_link_specifier`: Allows a typed link specifier to be accepted as input.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the typed link resides. For more information, see arns or Typed Links.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConsistencyLevel"`: The consistency level at which to retrieve the attributes on a
typed link.
"""
function get_link_attributes(
AttributeNames,
TypedLinkSpecifier,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/attributes/get",
Dict{String,Any}(
"AttributeNames" => AttributeNames,
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_link_attributes(
AttributeNames,
TypedLinkSpecifier,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/attributes/get",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AttributeNames" => AttributeNames,
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_object_attributes(attribute_names, object_reference, schema_facet, x-amz-data-partition)
get_object_attributes(attribute_names, object_reference, schema_facet, x-amz-data-partition, params::Dict{String,<:Any})
Retrieves attributes within a facet that are associated with an object.
# Arguments
- `attribute_names`: List of attribute names whose values will be retrieved.
- `object_reference`: Reference that identifies the object whose attributes will be
retrieved.
- `schema_facet`: Identifier for the facet whose attributes will be retrieved. See
SchemaFacet for details.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-consistency-level"`: The consistency level at which to retrieve the attributes on
an object.
"""
function get_object_attributes(
AttributeNames,
ObjectReference,
SchemaFacet,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/attributes/get",
Dict{String,Any}(
"AttributeNames" => AttributeNames,
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_object_attributes(
AttributeNames,
ObjectReference,
SchemaFacet,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/attributes/get",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AttributeNames" => AttributeNames,
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_object_information(object_reference, x-amz-data-partition)
get_object_information(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Retrieves metadata about an object.
# Arguments
- `object_reference`: A reference to the object.
- `x-amz-data-partition`: The ARN of the directory being retrieved.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-consistency-level"`: The consistency level at which to retrieve the object
information.
"""
function get_object_information(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/information",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_object_information(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/information",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_schema_as_json(x-amz-data-partition)
get_schema_as_json(x-amz-data-partition, params::Dict{String,<:Any})
Retrieves a JSON representation of the schema. See JSON Schema Format for more information.
# Arguments
- `x-amz-data-partition`: The ARN of the schema to retrieve.
"""
function get_schema_as_json(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/json",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_schema_as_json(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/json",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_typed_link_facet_information(name, x-amz-data-partition)
get_typed_link_facet_information(name, x-amz-data-partition, params::Dict{String,<:Any})
Returns the identity attribute order for a specific TypedLinkFacet. For more information,
see Typed Links.
# Arguments
- `name`: The unique name of the typed link facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
"""
function get_typed_link_facet_information(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/get",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_typed_link_facet_information(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/get",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_applied_schema_arns(directory_arn)
list_applied_schema_arns(directory_arn, params::Dict{String,<:Any})
Lists schema major versions applied to a directory. If SchemaArn is provided, lists the
minor version.
# Arguments
- `directory_arn`: The ARN of the directory you are listing.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
- `"SchemaArn"`: The response for ListAppliedSchemaArns when this parameter is used will
list all minor version ARNs for a major version.
"""
function list_applied_schema_arns(
DirectoryArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/applied",
Dict{String,Any}("DirectoryArn" => DirectoryArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_applied_schema_arns(
DirectoryArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/applied",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DirectoryArn" => DirectoryArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_attached_indices(target_reference, x-amz-data-partition)
list_attached_indices(target_reference, x-amz-data-partition, params::Dict{String,<:Any})
Lists indices attached to the specified object.
# Arguments
- `target_reference`: A reference to the object that has indices attached.
- `x-amz-data-partition`: The ARN of the directory.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: The consistency level to use for this operation.
"""
function list_attached_indices(
TargetReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/indices",
Dict{String,Any}(
"TargetReference" => TargetReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_attached_indices(
TargetReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/indices",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TargetReference" => TargetReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_development_schema_arns()
list_development_schema_arns(params::Dict{String,<:Any})
Retrieves each Amazon Resource Name (ARN) of schemas in the development state.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_development_schema_arns(; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/development";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_development_schema_arns(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/development",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_directories()
list_directories(params::Dict{String,<:Any})
Lists directories created within an account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
- `"state"`: The state of the directories in the list. Can be either Enabled, Disabled, or
Deleted.
"""
function list_directories(; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/directory/list";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_directories(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/directory/list",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_facet_attributes(name, x-amz-data-partition)
list_facet_attributes(name, x-amz-data-partition, params::Dict{String,<:Any})
Retrieves attributes attached to the facet.
# Arguments
- `name`: The name of the facet whose attributes will be retrieved.
- `x-amz-data-partition`: The ARN of the schema where the facet resides.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_facet_attributes(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet/attributes",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_facet_attributes(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet/attributes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_facet_names(x-amz-data-partition)
list_facet_names(x-amz-data-partition, params::Dict{String,<:Any})
Retrieves the names of facets that exist in a schema.
# Arguments
- `x-amz-data-partition`: The Amazon Resource Name (ARN) to retrieve facet names from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_facet_names(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet/list",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_facet_names(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/facet/list",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_incoming_typed_links(object_reference, x-amz-data-partition)
list_incoming_typed_links(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Returns a paginated list of all the incoming TypedLinkSpecifier information for an object.
It also supports filtering by typed link facet and identity attributes. For more
information, see Typed Links.
# Arguments
- `object_reference`: Reference that identifies the object whose attributes will be listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory where you want to
list the typed links.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConsistencyLevel"`: The consistency level to execute the request at.
- `"FilterAttributeRanges"`: Provides range filters for multiple attributes. When providing
ranges to typed link selection, any inexact ranges must be specified at the end. Any
attributes that do not have a range specified are presumed to match the entire range.
- `"FilterTypedLink"`: Filters are interpreted in the order of the attributes on the typed
link facet, not the order in which they are supplied to any API calls.
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_incoming_typed_links(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/incoming",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_incoming_typed_links(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/incoming",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_index(index_reference, x-amz-data-partition)
list_index(index_reference, x-amz-data-partition, params::Dict{String,<:Any})
Lists objects attached to the specified index.
# Arguments
- `index_reference`: The reference to the index to list.
- `x-amz-data-partition`: The ARN of the directory that the index exists in.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of objects in a single page to retrieve from the index
during a request. For more information, see Amazon Cloud Directory Limits.
- `"NextToken"`: The pagination token.
- `"RangesOnIndexedValues"`: Specifies the ranges of indexed values that you want to query.
- `"x-amz-consistency-level"`: The consistency level to execute the request at.
"""
function list_index(
IndexReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/index/targets",
Dict{String,Any}(
"IndexReference" => IndexReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_index(
IndexReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/index/targets",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IndexReference" => IndexReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_managed_schema_arns()
list_managed_schema_arns(params::Dict{String,<:Any})
Lists the major version families of each managed schema. If a major version ARN is provided
as SchemaArn, the minor version revisions in that family are listed instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
- `"SchemaArn"`: The response for ListManagedSchemaArns. When this parameter is used, all
minor version ARNs for a major version are listed.
"""
function list_managed_schema_arns(; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/managed";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_managed_schema_arns(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/managed",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_object_attributes(object_reference, x-amz-data-partition)
list_object_attributes(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Lists all attributes that are associated with an object.
# Arguments
- `object_reference`: The reference that identifies the object whose attributes will be
listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"FacetFilter"`: Used to filter the list of object attributes that are associated with a
certain facet.
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function list_object_attributes(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/attributes",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_object_attributes(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/attributes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_object_children(object_reference, x-amz-data-partition)
list_object_children(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Returns a paginated list of child objects that are associated with a given object.
# Arguments
- `object_reference`: The reference that identifies the object for which child objects are
being listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function list_object_children(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/children",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_object_children(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/children",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_object_parent_paths(object_reference, x-amz-data-partition)
list_object_parent_paths(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Retrieves all available parent paths for any object type such as node, leaf node, policy
node, and index node objects. For more information about objects, see Directory Structure.
Use this API to evaluate all parents for an object. The call returns all objects from the
root of the directory up to the requested object. The API returns the number of paths based
on user-defined MaxResults, in case there are multiple paths to the parent. The order of
the paths and nodes returned is consistent among multiple API calls unless the objects are
deleted or moved. Paths not leading to the directory root are ignored from the target
object.
# Arguments
- `object_reference`: The reference that identifies the object whose parent paths are
listed.
- `x-amz-data-partition`: The ARN of the directory to which the parent path applies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
"""
function list_object_parent_paths(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/parentpaths",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_object_parent_paths(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/parentpaths",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_object_parents(object_reference, x-amz-data-partition)
list_object_parents(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Lists parent objects that are associated with a given object in pagination fashion.
# Arguments
- `object_reference`: The reference that identifies the object for which parent objects are
being listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IncludeAllLinksToEachParent"`: When set to True, returns all
ListObjectParentsResponseParentLinks. There could be multiple links between a parent-child
pair.
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function list_object_parents(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/parent",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_object_parents(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/parent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_object_policies(object_reference, x-amz-data-partition)
list_object_policies(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Returns policies attached to an object in pagination fashion.
# Arguments
- `object_reference`: Reference that identifies the object for which policies will be
listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where objects reside. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function list_object_policies(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/policy",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_object_policies(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/object/policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_outgoing_typed_links(object_reference, x-amz-data-partition)
list_outgoing_typed_links(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Returns a paginated list of all the outgoing TypedLinkSpecifier information for an object.
It also supports filtering by typed link facet and identity attributes. For more
information, see Typed Links.
# Arguments
- `object_reference`: A reference that identifies the object whose attributes will be
listed.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the directory where you want to
list the typed links.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConsistencyLevel"`: The consistency level to execute the request at.
- `"FilterAttributeRanges"`: Provides range filters for multiple attributes. When providing
ranges to typed link selection, any inexact ranges must be specified at the end. Any
attributes that do not have a range specified are presumed to match the entire range.
- `"FilterTypedLink"`: Filters are interpreted in the order of the attributes defined on
the typed link facet, not the order they are supplied to any API calls.
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_outgoing_typed_links(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/outgoing",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_outgoing_typed_links(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/outgoing",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_policy_attachments(policy_reference, x-amz-data-partition)
list_policy_attachments(policy_reference, x-amz-data-partition, params::Dict{String,<:Any})
Returns all of the ObjectIdentifiers to which a given policy is attached.
# Arguments
- `policy_reference`: The reference that identifies the policy object.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where objects reside. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The pagination token.
- `"x-amz-consistency-level"`: Represents the manner and timing in which the successful
write or update of an object is reflected in a subsequent read operation of that same
object.
"""
function list_policy_attachments(
PolicyReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/policy/attachment",
Dict{String,Any}(
"PolicyReference" => PolicyReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_policy_attachments(
PolicyReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/policy/attachment",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"PolicyReference" => PolicyReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_published_schema_arns()
list_published_schema_arns(params::Dict{String,<:Any})
Lists the major version families of each published schema. If a major version ARN is
provided as SchemaArn, the minor version revisions in that family are listed instead.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
- `"SchemaArn"`: The response for ListPublishedSchemaArns when this parameter is used will
list all minor version ARNs for a major version.
"""
function list_published_schema_arns(; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/published";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_published_schema_arns(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/schema/published",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns tags for a resource. Tagging is currently supported only for directories with a
limit of 50 tags per directory. All 50 tags are returned for a given directory with this
API call.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource. Tagging is only supported
for directories.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The MaxResults parameter sets the maximum number of results returned in a
single page. This is for future use and is not supported currently.
- `"NextToken"`: The pagination token. This is for future use. Currently pagination is not
supported for tagging.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/tags",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/tags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_typed_link_facet_attributes(name, x-amz-data-partition)
list_typed_link_facet_attributes(name, x-amz-data-partition, params::Dict{String,<:Any})
Returns a paginated list of all attribute definitions for a particular TypedLinkFacet. For
more information, see Typed Links.
# Arguments
- `name`: The unique name of the typed link facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_typed_link_facet_attributes(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/attributes",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_typed_link_facet_attributes(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/attributes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_typed_link_facet_names(x-amz-data-partition)
list_typed_link_facet_names(x-amz-data-partition, params::Dict{String,<:Any})
Returns a paginated list of TypedLink facet names for a particular schema. For more
information, see Typed Links.
# Arguments
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to retrieve.
- `"NextToken"`: The pagination token.
"""
function list_typed_link_facet_names(
x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/list",
Dict{String,Any}(
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_typed_link_facet_names(
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/facet/list",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
lookup_policy(object_reference, x-amz-data-partition)
lookup_policy(object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Lists all policies from the root of the Directory to the object specified. If there are no
policies present, an empty list is returned. If policies are present, and if some objects
don't have the policies attached, it returns the ObjectIdentifier for such objects. If
policies are present, it returns ObjectIdentifier, policyId, and policyType. Paths that
don't lead to the root from the target object are ignored. For more information, see
Policies.
# Arguments
- `object_reference`: Reference that identifies the object whose policies will be looked up.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of items to be retrieved in a single call. This is an
approximate number.
- `"NextToken"`: The token to request the next page of results.
"""
function lookup_policy(
ObjectReference, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/policy/lookup",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function lookup_policy(
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/policy/lookup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
publish_schema(version, x-amz-data-partition)
publish_schema(version, x-amz-data-partition, params::Dict{String,<:Any})
Publishes a development schema with a major version and a recommended minor version.
# Arguments
- `version`: The major version under which the schema will be published. Schemas have both
a major and minor version associated with them.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
development schema. For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MinorVersion"`: The minor version under which the schema will be published. This
parameter is recommended. Schemas have both a major and minor version associated with them.
- `"Name"`: The new name under which the schema will be published. If this is not provided,
the development schema is considered.
"""
function publish_schema(
Version, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/publish",
Dict{String,Any}(
"Version" => Version,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function publish_schema(
Version,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/publish",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Version" => Version,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_schema_from_json(document, x-amz-data-partition)
put_schema_from_json(document, x-amz-data-partition, params::Dict{String,<:Any})
Allows a schema to be updated using JSON upload. Only available for development schemas.
See JSON Schema Format for more information.
# Arguments
- `document`: The replacement JSON schema.
- `x-amz-data-partition`: The ARN of the schema to update.
"""
function put_schema_from_json(
Document, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/json",
Dict{String,Any}(
"Document" => Document,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_schema_from_json(
Document,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/json",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Document" => Document,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_facet_from_object(object_reference, schema_facet, x-amz-data-partition)
remove_facet_from_object(object_reference, schema_facet, x-amz-data-partition, params::Dict{String,<:Any})
Removes the specified facet from the specified object.
# Arguments
- `object_reference`: A reference to the object to remove the facet from.
- `schema_facet`: The facet to remove. See SchemaFacet for details.
- `x-amz-data-partition`: The ARN of the directory in which the object resides.
"""
function remove_facet_from_object(
ObjectReference,
SchemaFacet,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/facets/delete",
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_facet_from_object(
ObjectReference,
SchemaFacet,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/facets/delete",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ObjectReference" => ObjectReference,
"SchemaFacet" => SchemaFacet,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
An API operation for adding tags to a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource. Tagging is only supported
for directories.
- `tags`: A list of tag key-value pairs.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/tags/add",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/tags/add",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
An API operation for removing tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource. Tagging is only supported
for directories.
- `tag_keys`: Keys of the tag that need to be removed from the resource.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/tags/remove",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/tags/remove",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_facet(name, x-amz-data-partition)
update_facet(name, x-amz-data-partition, params::Dict{String,<:Any})
Does the following: Adds new Attributes, Rules, or ObjectTypes. Updates existing
Attributes, Rules, or ObjectTypes. Deletes existing Attributes, Rules, or ObjectTypes.
# Arguments
- `name`: The name of the facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the Facet.
For more information, see arns.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AttributeUpdates"`: List of attributes that need to be updated in a given schema Facet.
Each attribute is followed by AttributeAction, which specifies the type of update operation
to perform.
- `"ObjectType"`: The object type that is associated with the facet. See
CreateFacetRequestObjectType for more details.
"""
function update_facet(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_facet(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/facet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_link_attributes(attribute_updates, typed_link_specifier, x-amz-data-partition)
update_link_attributes(attribute_updates, typed_link_specifier, x-amz-data-partition, params::Dict{String,<:Any})
Updates a given typed link’s attributes. Attributes to be updated must not contribute to
the typed link’s identity, as defined by its IdentityAttributeOrder.
# Arguments
- `attribute_updates`: The attributes update structure.
- `typed_link_specifier`: Allows a typed link specifier to be accepted as input.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the updated typed link resides. For more information, see arns or Typed
Links.
"""
function update_link_attributes(
AttributeUpdates,
TypedLinkSpecifier,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/attributes/update",
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_link_attributes(
AttributeUpdates,
TypedLinkSpecifier,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"POST",
"/amazonclouddirectory/2017-01-11/typedlink/attributes/update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"TypedLinkSpecifier" => TypedLinkSpecifier,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_object_attributes(attribute_updates, object_reference, x-amz-data-partition)
update_object_attributes(attribute_updates, object_reference, x-amz-data-partition, params::Dict{String,<:Any})
Updates a given object's attributes.
# Arguments
- `attribute_updates`: The attributes update structure.
- `object_reference`: The reference that identifies the object.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
Directory where the object resides. For more information, see arns.
"""
function update_object_attributes(
AttributeUpdates,
ObjectReference,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/update",
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"ObjectReference" => ObjectReference,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_object_attributes(
AttributeUpdates,
ObjectReference,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/object/update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"ObjectReference" => ObjectReference,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_schema(name, x-amz-data-partition)
update_schema(name, x-amz-data-partition, params::Dict{String,<:Any})
Updates the schema name with a new name. Only development schema names can be updated.
# Arguments
- `name`: The name of the schema.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) of the development schema. For
more information, see arns.
"""
function update_schema(
Name, x_amz_data_partition; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/update",
Dict{String,Any}(
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_schema(
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/update",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_typed_link_facet(attribute_updates, identity_attribute_order, name, x-amz-data-partition)
update_typed_link_facet(attribute_updates, identity_attribute_order, name, x-amz-data-partition, params::Dict{String,<:Any})
Updates a TypedLinkFacet. For more information, see Typed Links.
# Arguments
- `attribute_updates`: Attributes update structure.
- `identity_attribute_order`: The order of identity attributes for the facet, from most
significant to least significant. The ability to filter typed links considers the order
that the attributes are defined on the typed link facet. When providing ranges to a typed
link selection, any inexact ranges must be specified at the end. Any attributes that do not
have a range specified are presumed to match the entire range. Filters are interpreted in
the order of the attributes on the typed link facet, not the order in which they are
supplied to any API calls. For more information about identity attributes, see Typed Links.
- `name`: The unique name of the typed link facet.
- `x-amz-data-partition`: The Amazon Resource Name (ARN) that is associated with the
schema. For more information, see arns.
"""
function update_typed_link_facet(
AttributeUpdates,
IdentityAttributeOrder,
Name,
x_amz_data_partition;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet",
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"IdentityAttributeOrder" => IdentityAttributeOrder,
"Name" => Name,
"headers" => Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_typed_link_facet(
AttributeUpdates,
IdentityAttributeOrder,
Name,
x_amz_data_partition,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/typedlink/facet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AttributeUpdates" => AttributeUpdates,
"IdentityAttributeOrder" => IdentityAttributeOrder,
"Name" => Name,
"headers" =>
Dict{String,Any}("x-amz-data-partition" => x_amz_data_partition),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
upgrade_applied_schema(directory_arn, published_schema_arn)
upgrade_applied_schema(directory_arn, published_schema_arn, params::Dict{String,<:Any})
Upgrades a single directory in-place using the PublishedSchemaArn with schema updates found
in MinorVersion. Backwards-compatible minor version upgrades are instantaneously available
for readers on all objects in the directory. Note: This is a synchronous API call and
upgrades only one schema on a given directory per call. To upgrade multiple directories
from one schema, you would need to call this API on each directory.
# Arguments
- `directory_arn`: The ARN for the directory to which the upgraded schema will be applied.
- `published_schema_arn`: The revision of the published schema to upgrade the directory to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DryRun"`: Used for testing whether the major version schemas are backward compatible or
not. If schema compatibility fails, an exception would be thrown else the call would
succeed but no changes will be saved. This parameter is optional.
"""
function upgrade_applied_schema(
DirectoryArn, PublishedSchemaArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/upgradeapplied",
Dict{String,Any}(
"DirectoryArn" => DirectoryArn, "PublishedSchemaArn" => PublishedSchemaArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function upgrade_applied_schema(
DirectoryArn,
PublishedSchemaArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/upgradeapplied",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DirectoryArn" => DirectoryArn,
"PublishedSchemaArn" => PublishedSchemaArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
upgrade_published_schema(development_schema_arn, minor_version, published_schema_arn)
upgrade_published_schema(development_schema_arn, minor_version, published_schema_arn, params::Dict{String,<:Any})
Upgrades a published schema under a new minor version revision using the current contents
of DevelopmentSchemaArn.
# Arguments
- `development_schema_arn`: The ARN of the development schema with the changes used for the
upgrade.
- `minor_version`: Identifies the minor version of the published schema that will be
created. This parameter is NOT optional.
- `published_schema_arn`: The ARN of the published schema to be upgraded.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DryRun"`: Used for testing whether the Development schema provided is backwards
compatible, or not, with the publish schema provided by the user to be upgraded. If schema
compatibility fails, an exception would be thrown else the call would succeed. This
parameter is optional and defaults to false.
"""
function upgrade_published_schema(
DevelopmentSchemaArn,
MinorVersion,
PublishedSchemaArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/upgradepublished",
Dict{String,Any}(
"DevelopmentSchemaArn" => DevelopmentSchemaArn,
"MinorVersion" => MinorVersion,
"PublishedSchemaArn" => PublishedSchemaArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function upgrade_published_schema(
DevelopmentSchemaArn,
MinorVersion,
PublishedSchemaArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return clouddirectory(
"PUT",
"/amazonclouddirectory/2017-01-11/schema/upgradepublished",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DevelopmentSchemaArn" => DevelopmentSchemaArn,
"MinorVersion" => MinorVersion,
"PublishedSchemaArn" => PublishedSchemaArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 222143 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudformation
using AWS.Compat
using AWS.UUIDs
"""
activate_organizations_access()
activate_organizations_access(params::Dict{String,<:Any})
Activate trusted access with Organizations. With trusted access between StackSets and
Organizations activated, the management account has permissions to create and manage
StackSets for your organization.
"""
function activate_organizations_access(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ActivateOrganizationsAccess";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function activate_organizations_access(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ActivateOrganizationsAccess",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
activate_type()
activate_type(params::Dict{String,<:Any})
Activates a public third-party extension, making it available for use in stack templates.
For more information, see Using public extensions in the CloudFormation User Guide. Once
you have activated a public third-party extension in your account and Region, use
SetTypeConfiguration to specify configuration properties for the extension. For more
information, see Configuring extensions at the account level in the CloudFormation User
Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AutoUpdate"`: Whether to automatically update the extension in this account and Region
when a new minor version is published by the extension publisher. Major versions released
by the publisher must be manually updated. The default is true.
- `"ExecutionRoleArn"`: The name of the IAM execution role to use to activate the extension.
- `"LoggingConfig"`: Contains logging configuration information for an extension.
- `"MajorVersion"`: The major version of this extension you want to activate, if multiple
major versions are available. The default is the latest major version. CloudFormation uses
the latest available minor version of the major version selected. You can specify
MajorVersion or VersionBump, but not both.
- `"PublicTypeArn"`: The Amazon Resource Name (ARN) of the public extension. Conditional:
You must specify PublicTypeArn, or TypeName, Type, and PublisherId.
- `"PublisherId"`: The ID of the extension publisher. Conditional: You must specify
PublicTypeArn, or TypeName, Type, and PublisherId.
- `"Type"`: The extension type. Conditional: You must specify PublicTypeArn, or TypeName,
Type, and PublisherId.
- `"TypeName"`: The name of the extension. Conditional: You must specify PublicTypeArn, or
TypeName, Type, and PublisherId.
- `"TypeNameAlias"`: An alias to assign to the public extension, in this account and
Region. If you specify an alias for the extension, CloudFormation treats the alias as the
extension type name within this account and Region. You must use the alias to refer to the
extension in your templates, API calls, and CloudFormation console. An extension alias must
be unique within a given account and Region. You can activate the same public resource
multiple times in the same account and Region, using different type name aliases.
- `"VersionBump"`: Manually updates a previously-activated type to a new major or minor
version, if available. You can also use this parameter to update the value of AutoUpdate.
MAJOR: CloudFormation updates the extension to the newest major version, if one is
available. MINOR: CloudFormation updates the extension to the newest minor version, if
one is available.
"""
function activate_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ActivateType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function activate_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ActivateType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
batch_describe_type_configurations(type_configuration_identifiers)
batch_describe_type_configurations(type_configuration_identifiers, params::Dict{String,<:Any})
Returns configuration data for the specified CloudFormation extensions, from the
CloudFormation registry for the account and Region. For more information, see Configuring
extensions at the account level in the CloudFormation User Guide.
# Arguments
- `type_configuration_identifiers`: The list of identifiers for the desired extension
configurations.
"""
function batch_describe_type_configurations(
TypeConfigurationIdentifiers; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"BatchDescribeTypeConfigurations",
Dict{String,Any}("TypeConfigurationIdentifiers" => TypeConfigurationIdentifiers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_describe_type_configurations(
TypeConfigurationIdentifiers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"BatchDescribeTypeConfigurations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"TypeConfigurationIdentifiers" => TypeConfigurationIdentifiers
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_update_stack(stack_name)
cancel_update_stack(stack_name, params::Dict{String,<:Any})
Cancels an update on the specified stack. If the call completes successfully, the stack
rolls back the update and reverts to the previous stack configuration. You can cancel only
stacks that are in the UPDATE_IN_PROGRESS state.
# Arguments
- `stack_name`: If you don't pass a parameter to StackName, the API returns a response
that describes all resources in the account. The IAM policy below can be added to IAM
policies when you want to limit resource-level permissions and avoid returning a response
when no parameter is sent in the request: { \"Version\": \"2012-10-17\", \"Statement\": [{
\"Effect\": \"Deny\", \"Action\": \"cloudformation:DescribeStacks\", \"NotResource\":
\"arn:aws:cloudformation:*:*:stack/*/*\" }] } The name or the unique stack ID that's
associated with the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this CancelUpdateStack request. Specify
this token if you plan to retry requests so that CloudFormation knows that you're not
attempting to cancel an update on a stack with the same name. You might retry
CancelUpdateStack requests to ensure that CloudFormation successfully received them.
"""
function cancel_update_stack(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"CancelUpdateStack",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_update_stack(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CancelUpdateStack",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
continue_update_rollback(stack_name)
continue_update_rollback(stack_name, params::Dict{String,<:Any})
For a specified stack that's in the UPDATE_ROLLBACK_FAILED state, continues rolling it back
to the UPDATE_ROLLBACK_COMPLETE state. Depending on the cause of the failure, you can
manually fix the error and continue the rollback. By continuing the rollback, you can
return your stack to a working state (the UPDATE_ROLLBACK_COMPLETE state), and then try to
update the stack again. A stack goes into the UPDATE_ROLLBACK_FAILED state when
CloudFormation can't roll back all changes after a failed stack update. For example, you
might have a stack that's rolling back to an old database instance that was deleted outside
of CloudFormation. Because CloudFormation doesn't know the database was deleted, it assumes
that the database instance still exists and attempts to roll back to it, causing the update
rollback to fail.
# Arguments
- `stack_name`: The name or the unique ID of the stack that you want to continue rolling
back. Don't specify the name of a nested stack (a stack that was created by using the
AWS::CloudFormation::Stack resource). Instead, use this operation on the parent stack (the
stack that contains the AWS::CloudFormation::Stack resource).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this ContinueUpdateRollback request.
Specify this token if you plan to retry requests so that CloudFormation knows that you're
not attempting to continue the rollback to a stack with the same name. You might retry
ContinueUpdateRollback requests to ensure that CloudFormation successfully received them.
- `"ResourcesToSkip"`: A list of the logical IDs of the resources that CloudFormation skips
during the continue update rollback operation. You can specify only resources that are in
the UPDATE_FAILED state because a rollback failed. You can't specify resources that are in
the UPDATE_FAILED state for other reasons, for example, because an update was canceled. To
check why a resource update failed, use the DescribeStackResources action, and view the
resource status reason. Specify this property to skip rolling back resources that
CloudFormation can't successfully roll back. We recommend that you troubleshoot resources
before skipping them. CloudFormation sets the status of the specified resources to
UPDATE_COMPLETE and continues to roll back the stack. After the rollback is complete, the
state of the skipped resources will be inconsistent with the state of the resources in the
stack template. Before performing another stack update, you must update the stack or
resources to be consistent with each other. If you don't, subsequent stack updates might
fail, and the stack will become unrecoverable. Specify the minimum number of resources
required to successfully roll back your stack. For example, a failed resource update might
cause dependent resources to fail. In this case, it might not be necessary to skip the
dependent resources. To skip resources that are part of nested stacks, use the following
format: NestedStackName.ResourceLogicalID. If you want to specify the logical ID of a stack
resource (Type: AWS::CloudFormation::Stack) in the ResourcesToSkip list, then its
corresponding embedded stack must be in one of the following states: DELETE_IN_PROGRESS,
DELETE_COMPLETE, or DELETE_FAILED. Don't confuse a child stack's name with its
corresponding logical ID defined in the parent stack. For an example of a continue update
rollback operation with nested stacks, see Using ResourcesToSkip to recover a nested stacks
hierarchy.
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management (IAM)
role that CloudFormation assumes to roll back the stack. CloudFormation uses the role's
credentials to make calls on your behalf. CloudFormation always uses this role for all
future operations on the stack. Provided that users have permission to operate on the
stack, CloudFormation uses this role even if the users don't have permission to pass it.
Ensure that the role grants least permission. If you don't specify a value, CloudFormation
uses the role that was previously associated with the stack. If no role is available,
CloudFormation uses a temporary session that's generated from your user credentials.
"""
function continue_update_rollback(
StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ContinueUpdateRollback",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function continue_update_rollback(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ContinueUpdateRollback",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_change_set(change_set_name, stack_name)
create_change_set(change_set_name, stack_name, params::Dict{String,<:Any})
Creates a list of changes that will be applied to a stack so that you can review the
changes before executing them. You can create a change set for a stack that doesn't exist
or an existing stack. If you create a change set for a stack that doesn't exist, the change
set shows all of the resources that CloudFormation will create. If you create a change set
for an existing stack, CloudFormation compares the stack's information with the information
that you submit in the change set and lists the differences. Use change sets to understand
which resources CloudFormation will create or change, and how it will change resources in
an existing stack, before you create or update a stack. To create a change set for a stack
that doesn't exist, for the ChangeSetType parameter, specify CREATE. To create a change set
for an existing stack, specify UPDATE for the ChangeSetType parameter. To create a change
set for an import operation, specify IMPORT for the ChangeSetType parameter. After the
CreateChangeSet call successfully completes, CloudFormation starts creating the change set.
To check the status of the change set or to review it, use the DescribeChangeSet action.
When you are satisfied with the changes the change set will make, execute the change set by
using the ExecuteChangeSet action. CloudFormation doesn't make changes until you execute
the change set. To create a change set for the entire stack hierarchy, set
IncludeNestedStacks to True.
# Arguments
- `change_set_name`: The name of the change set. The name must be unique among all change
sets that are associated with the specified stack. A change set name can contain only
alphanumeric, case sensitive characters, and hyphens. It must start with an alphabetical
character and can't exceed 128 characters.
- `stack_name`: The name or the unique ID of the stack for which you are creating a change
set. CloudFormation generates the change set by comparing this stack's information with the
information that you submit, such as a modified template or different parameter input
values.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Capabilities"`: In some cases, you must explicitly acknowledge that your stack template
contains certain capabilities in order for CloudFormation to create the stack.
CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack templates might include resources that
can affect permissions in your Amazon Web Services account; for example, by creating new
Identity and Access Management (IAM) users. For those stacks, you must explicitly
acknowledge this by specifying one of these capabilities. The following IAM resources
require you to specify either the CAPABILITY_IAM or CAPABILITY_NAMED_IAM capability. If
you have IAM resources, you can specify either capability. If you have IAM resources with
custom names, you must specify CAPABILITY_NAMED_IAM. If you don't specify either of these
capabilities, CloudFormation returns an InsufficientCapabilities error. If your stack
template contains these resources, we suggest that you review all permissions associated
with them and edit their permissions if necessary. AWS::IAM::AccessKey
AWS::IAM::Group AWS::IAM::InstanceProfile AWS::IAM::Policy AWS::IAM::Role
AWS::IAM::User AWS::IAM::UserToGroupAddition For more information, see
Acknowledging IAM resources in CloudFormation templates. CAPABILITY_AUTO_EXPAND Some
template contain macros. Macros perform custom processing on templates; this can include
simple actions like find-and-replace operations, all the way to extensive transformations
of entire templates. Because of this, users typically create a change set from the
processed template, so that they can review the changes resulting from the macros before
actually creating the stack. If your stack template contains one or more macros, and you
choose to create a stack directly from the processed template, without first reviewing the
resulting changes in a change set, you must acknowledge this capability. This includes the
AWS::Include and AWS::Serverless transforms, which are macros hosted by CloudFormation.
This capacity doesn't apply to creating change sets, and specifying it when creating change
sets has no effect. If you want to create a stack from a stack template that contains
macros and nested stacks, you must create or update the stack directly from the template
using the CreateStack or UpdateStack action, and specifying this capability. For more
information about macros, see Using CloudFormation macros to perform custom processing on
templates. Only one of the Capabilities and ResourceType parameters can be specified.
- `"ChangeSetType"`: The type of change set operation. To create a change set for a new
stack, specify CREATE. To create a change set for an existing stack, specify UPDATE. To
create a change set for an import operation, specify IMPORT. If you create a change set for
a new stack, CloudFormation creates a stack with a unique stack ID, but no template or
resources. The stack will be in the REVIEW_IN_PROGRESS state until you execute the change
set. By default, CloudFormation specifies UPDATE. You can't use the UPDATE type to create a
change set for a new stack or the CREATE type to create a change set for an existing stack.
- `"ClientToken"`: A unique identifier for this CreateChangeSet request. Specify this token
if you plan to retry requests so that CloudFormation knows that you're not attempting to
create another change set with the same name. You might retry CreateChangeSet requests to
ensure that CloudFormation successfully received them.
- `"Description"`: A description to help you identify this change set.
- `"ImportExistingResources"`: Indicates if the change set imports resources that already
exist. This parameter can only import resources that have custom names in templates. For
more information, see name type in the CloudFormation User Guide. To import resources that
do not accept custom names, such as EC2 instances, use the resource import feature instead.
For more information, see Bringing existing resources into CloudFormation management in the
CloudFormation User Guide.
- `"IncludeNestedStacks"`: Creates a change set for the all nested stacks specified in the
template. The default behavior of this action is set to False. To include nested sets in a
change set, specify True.
- `"NotificationARNs"`: The Amazon Resource Names (ARNs) of Amazon Simple Notification
Service (Amazon SNS) topics that CloudFormation associates with the stack. To remove all
associated notification topics, specify an empty list.
- `"OnStackFailure"`: Determines what action will be taken if stack creation fails. If this
parameter is specified, the DisableRollback parameter to the ExecuteChangeSet API operation
must not be specified. This must be one of these values: DELETE - Deletes the change set
if the stack creation fails. This is only valid when the ChangeSetType parameter is set to
CREATE. If the deletion of the stack fails, the status of the stack is DELETE_FAILED.
DO_NOTHING - if the stack creation fails, do nothing. This is equivalent to specifying true
for the DisableRollback parameter to the ExecuteChangeSet API operation. ROLLBACK - if
the stack creation fails, roll back the stack. This is equivalent to specifying false for
the DisableRollback parameter to the ExecuteChangeSet API operation. For nested stacks,
when the OnStackFailure parameter is set to DELETE for the change set for the parent stack,
any failure in a child stack will cause the parent stack creation to fail and all stacks to
be deleted.
- `"Parameters"`: A list of Parameter structures that specify input parameters for the
change set. For more information, see the Parameter data type.
- `"ResourceTypes"`: The template resource types that you have permissions to work with if
you execute this change set, such as AWS::EC2::Instance, AWS::EC2::*, or
Custom::MyCustomInstance. If the list of resource types doesn't include a resource type
that you're updating, the stack update fails. By default, CloudFormation grants permissions
to all resource types. Identity and Access Management (IAM) uses this parameter for
condition keys in IAM policies for CloudFormation. For more information, see Controlling
access with Identity and Access Management in the CloudFormation User Guide. Only one of
the Capabilities and ResourceType parameters can be specified.
- `"ResourcesToImport"`: The resources to import into your stack.
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management (IAM)
role that CloudFormation assumes when executing the change set. CloudFormation uses the
role's credentials to make calls on your behalf. CloudFormation uses this role for all
future operations on the stack. Provided that users have permission to operate on the
stack, CloudFormation uses this role even if the users don't have permission to pass it.
Ensure that the role grants least permission. If you don't specify a value, CloudFormation
uses the role that was previously associated with the stack. If no role is available,
CloudFormation uses a temporary session that is generated from your user credentials.
- `"RollbackConfiguration"`: The rollback triggers for CloudFormation to monitor during
stack creation and updating operations, and for the specified monitoring period afterwards.
- `"Tags"`: Key-value pairs to associate with this stack. CloudFormation also propagates
these tags to resources in the stack. You can specify a maximum of 50 tags.
- `"TemplateBody"`: A structure that contains the body of the revised template, with a
minimum length of 1 byte and a maximum length of 51,200 bytes. CloudFormation generates the
change set by comparing this template with the template of the stack that you specified.
Conditional: You must specify only TemplateBody or TemplateURL.
- `"TemplateURL"`: The location of the file that contains the revised template. The URL
must point to a template (max size: 460,800 bytes) that's located in an Amazon S3 bucket or
a Systems Manager document. CloudFormation generates the change set by comparing this
template with the stack that you specified. The location for an Amazon S3 bucket must start
with https://. Conditional: You must specify only TemplateBody or TemplateURL.
- `"UsePreviousTemplate"`: Whether to reuse the template that's associated with the stack
to create the change set.
"""
function create_change_set(
ChangeSetName, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"CreateChangeSet",
Dict{String,Any}("ChangeSetName" => ChangeSetName, "StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_change_set(
ChangeSetName,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CreateChangeSet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ChangeSetName" => ChangeSetName, "StackName" => StackName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_generated_template(generated_template_name)
create_generated_template(generated_template_name, params::Dict{String,<:Any})
Creates a template from existing resources that are not already managed with
CloudFormation. You can check the status of the template generation using the
DescribeGeneratedTemplate API action.
# Arguments
- `generated_template_name`: The name assigned to the generated template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Resources"`: An optional list of resources to be included in the generated template.
If no resources are specified,the template will be created without any resources. Resources
can be added to the template using the UpdateGeneratedTemplate API action.
- `"StackName"`: An optional name or ARN of a stack to use as the base stack for the
generated template.
- `"TemplateConfiguration"`: The configuration details of the generated template, including
the DeletionPolicy and UpdateReplacePolicy.
"""
function create_generated_template(
GeneratedTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"CreateGeneratedTemplate",
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_generated_template(
GeneratedTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CreateGeneratedTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stack(stack_name)
create_stack(stack_name, params::Dict{String,<:Any})
Creates a stack as specified in the template. After the call completes successfully, the
stack creation starts. You can check the status of the stack through the DescribeStacks
operation.
# Arguments
- `stack_name`: The name that's associated with the stack. The name must be unique in the
Region in which you are creating the stack. A stack name can contain only alphanumeric
characters (case sensitive) and hyphens. It must start with an alphabetical character and
can't be longer than 128 characters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Capabilities"`: In some cases, you must explicitly acknowledge that your stack template
contains certain capabilities in order for CloudFormation to create the stack.
CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack templates might include resources that
can affect permissions in your Amazon Web Services account; for example, by creating new
Identity and Access Management (IAM) users. For those stacks, you must explicitly
acknowledge this by specifying one of these capabilities. The following IAM resources
require you to specify either the CAPABILITY_IAM or CAPABILITY_NAMED_IAM capability. If
you have IAM resources, you can specify either capability. If you have IAM resources with
custom names, you must specify CAPABILITY_NAMED_IAM. If you don't specify either of these
capabilities, CloudFormation returns an InsufficientCapabilities error. If your stack
template contains these resources, we recommend that you review all permissions associated
with them and edit their permissions if necessary. AWS::IAM::AccessKey
AWS::IAM::Group AWS::IAM::InstanceProfile AWS::IAM::Policy AWS::IAM::Role
AWS::IAM::User AWS::IAM::UserToGroupAddition For more information, see Acknowledging
IAM Resources in CloudFormation Templates. CAPABILITY_AUTO_EXPAND Some template contain
macros. Macros perform custom processing on templates; this can include simple actions like
find-and-replace operations, all the way to extensive transformations of entire templates.
Because of this, users typically create a change set from the processed template, so that
they can review the changes resulting from the macros before actually creating the stack.
If your stack template contains one or more macros, and you choose to create a stack
directly from the processed template, without first reviewing the resulting changes in a
change set, you must acknowledge this capability. This includes the AWS::Include and
AWS::Serverless transforms, which are macros hosted by CloudFormation. If you want to
create a stack from a stack template that contains macros and nested stacks, you must
create the stack directly from the template using this capability. You should only create
stacks directly from a stack template that contains macros if you know what processing the
macro performs. Each macro relies on an underlying Lambda service function for processing
stack templates. Be aware that the Lambda function owner can update the function operation
without CloudFormation being notified. For more information, see Using CloudFormation
macros to perform custom processing on templates. Only one of the Capabilities and
ResourceType parameters can be specified.
- `"ClientRequestToken"`: A unique identifier for this CreateStack request. Specify this
token if you plan to retry requests so that CloudFormation knows that you're not attempting
to create a stack with the same name. You might retry CreateStack requests to ensure that
CloudFormation successfully received them. All events initiated by a given stack operation
are assigned the same client request token, which you can use to track operations. For
example, if you execute a CreateStack operation with the token token1, then all the
StackEvents generated by that operation will have ClientRequestToken set as token1. In the
console, stack operations display the client request token on the Events tab. Stack
operations that are initiated from the console use the token format
Console-StackOperation-ID, which helps you easily identify the stack operation . For
example, if you create a stack using the console, each stack event would be assigned the
same token in the following format:
Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002.
- `"DisableRollback"`: Set to true to disable rollback of the stack if stack creation
failed. You can specify either DisableRollback or OnFailure, but not both. Default: false
- `"EnableTerminationProtection"`: Whether to enable termination protection on the
specified stack. If a user attempts to delete a stack with termination protection enabled,
the operation fails and the stack remains unchanged. For more information, see Protecting a
Stack From Being Deleted in the CloudFormation User Guide. Termination protection is
deactivated on stacks by default. For nested stacks, termination protection is set on the
root stack and can't be changed directly on the nested stack.
- `"NotificationARNs"`: The Amazon Simple Notification Service (Amazon SNS) topic ARNs to
publish stack related events. You can find your Amazon SNS topic ARNs using the Amazon SNS
console or your Command Line Interface (CLI).
- `"OnFailure"`: Determines what action will be taken if stack creation fails. This must be
one of: DO_NOTHING, ROLLBACK, or DELETE. You can specify either OnFailure or
DisableRollback, but not both. Default: ROLLBACK
- `"Parameters"`: A list of Parameter structures that specify input parameters for the
stack. For more information, see the Parameter data type.
- `"ResourceTypes"`: The template resource types that you have permissions to work with for
this create stack action, such as AWS::EC2::Instance, AWS::EC2::*, or
Custom::MyCustomInstance. Use the following syntax to describe template resource types:
AWS::* (for all Amazon Web Services resources), Custom::* (for all custom resources),
Custom::logical_ID (for a specific custom resource), AWS::service_name::* (for all
resources of a particular Amazon Web Services service), and
AWS::service_name::resource_logical_ID (for a specific Amazon Web Services resource). If
the list of resource types doesn't include a resource that you're creating, the stack
creation fails. By default, CloudFormation grants permissions to all resource types.
Identity and Access Management (IAM) uses this parameter for CloudFormation-specific
condition keys in IAM policies. For more information, see Controlling Access with Identity
and Access Management. Only one of the Capabilities and ResourceType parameters can be
specified.
- `"RetainExceptOnCreate"`: When set to true, newly created resources are deleted when the
operation rolls back. This includes newly created resources marked with a deletion policy
of Retain. Default: false
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management (IAM)
role that CloudFormation assumes to create the stack. CloudFormation uses the role's
credentials to make calls on your behalf. CloudFormation always uses this role for all
future operations on the stack. Provided that users have permission to operate on the
stack, CloudFormation uses this role even if the users don't have permission to pass it.
Ensure that the role grants least privilege. If you don't specify a value, CloudFormation
uses the role that was previously associated with the stack. If no role is available,
CloudFormation uses a temporary session that's generated from your user credentials.
- `"RollbackConfiguration"`: The rollback triggers for CloudFormation to monitor during
stack creation and updating operations, and for the specified monitoring period afterwards.
- `"StackPolicyBody"`: Structure containing the stack policy body. For more information, go
to Prevent Updates to Stack Resources in the CloudFormation User Guide. You can specify
either the StackPolicyBody or the StackPolicyURL parameter, but not both.
- `"StackPolicyURL"`: Location of a file containing the stack policy. The URL must point to
a policy (maximum size: 16 KB) located in an S3 bucket in the same Region as the stack. The
location for an Amazon S3 bucket must start with https://. You can specify either the
StackPolicyBody or the StackPolicyURL parameter, but not both.
- `"Tags"`: Key-value pairs to associate with this stack. CloudFormation also propagates
these tags to the resources created in the stack. A maximum number of 50 tags can be
specified.
- `"TemplateBody"`: Structure containing the template body with a minimum length of 1 byte
and a maximum length of 51,200 bytes. For more information, go to Template anatomy in the
CloudFormation User Guide. Conditional: You must specify either the TemplateBody or the
TemplateURL parameter, but not both.
- `"TemplateURL"`: Location of file containing the template body. The URL must point to a
template (max size: 460,800 bytes) that's located in an Amazon S3 bucket or a Systems
Manager document. For more information, go to the Template anatomy in the CloudFormation
User Guide. The location for an Amazon S3 bucket must start with https://. Conditional: You
must specify either the TemplateBody or the TemplateURL parameter, but not both.
- `"TimeoutInMinutes"`: The amount of time that can pass before the stack status becomes
CREATE_FAILED; if DisableRollback is not set or is set to false, the stack will be rolled
back.
"""
function create_stack(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"CreateStack",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stack(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CreateStack",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stack_instances(regions, stack_set_name)
create_stack_instances(regions, stack_set_name, params::Dict{String,<:Any})
Creates stack instances for the specified accounts, within the specified Amazon Web
Services Regions. A stack instance refers to a stack in a specific account and Region. You
must specify at least one value for either Accounts or DeploymentTargets, and you must
specify at least one value for Regions.
# Arguments
- `regions`: The names of one or more Amazon Web Services Regions where you want to create
stack instances using the specified Amazon Web Services accounts.
- `stack_set_name`: The name or unique ID of the stack set that you want to create stack
instances from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accounts"`: [Self-managed permissions] The names of one or more Amazon Web Services
accounts that you want to create stack instances in the specified Region(s) for. You can
specify Accounts or DeploymentTargets, but not both.
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"DeploymentTargets"`: [Service-managed permissions] The Organizations accounts for which
to create stack instances in the specified Amazon Web Services Regions. You can specify
Accounts or DeploymentTargets, but not both.
- `"OperationId"`: The unique identifier for this stack set operation. The operation ID
also functions as an idempotency token, to ensure that CloudFormation performs the stack
set operation only once, even if you retry the request multiple times. You might retry
stack set operation requests to ensure that CloudFormation successfully received them. If
you don't specify an operation ID, the SDK generates one automatically. Repeating this
stack set operation with a new operation ID retries all stack instances whose status is
OUTDATED.
- `"OperationPreferences"`: Preferences for how CloudFormation performs this stack set
operation.
- `"ParameterOverrides"`: A list of stack set parameters whose values you want to override
in the selected stack instances. Any overridden parameter values will be applied to all
stack instances in the specified accounts and Amazon Web Services Regions. When specifying
parameters and their values, be aware of how CloudFormation sets parameter values during
stack instance operations: To override the current value for a parameter, include the
parameter and specify its value. To leave an overridden parameter set to its present
value, include the parameter and specify UsePreviousValue as true. (You can't specify both
a value and set UsePreviousValue to true.) To set an overridden parameter back to the
value specified in the stack set, specify a parameter list but don't include the parameter
in the list. To leave all parameters set to their present values, don't specify this
property at all. During stack set updates, any parameter values overridden for a stack
instance aren't updated, but retain their overridden value. You can only override the
parameter values that are specified in the stack set; to add or delete a parameter itself,
use UpdateStackSet to update the stack set template.
"""
function create_stack_instances(
Regions, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"CreateStackInstances",
Dict{String,Any}(
"Regions" => Regions,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stack_instances(
Regions,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CreateStackInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Regions" => Regions,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_stack_set(stack_set_name)
create_stack_set(stack_set_name, params::Dict{String,<:Any})
Creates a stack set.
# Arguments
- `stack_set_name`: The name to associate with the stack set. The name must be unique in
the Region where you create your stack set. A stack name can contain only alphanumeric
characters (case-sensitive) and hyphens. It must start with an alphabetic character and
can't be longer than 128 characters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdministrationRoleARN"`: The Amazon Resource Name (ARN) of the IAM role to use to
create this stack set. Specify an IAM role only if you are using customized administrator
roles to control which users or groups can manage specific stack sets within the same
administrator account. For more information, see Prerequisites: Granting Permissions for
Stack Set Operations in the CloudFormation User Guide.
- `"AutoDeployment"`: Describes whether StackSets automatically deploys to Organizations
accounts that are added to the target organization or organizational unit (OU). Specify
only if PermissionModel is SERVICE_MANAGED.
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. To create a stack set with service-managed permissions while signed in to
the management account, specify SELF. To create a stack set with service-managed
permissions while signed in to a delegated administrator account, specify DELEGATED_ADMIN.
Your Amazon Web Services account must be registered as a delegated admin in the management
account. For more information, see Register a delegated administrator in the CloudFormation
User Guide. Stack sets with service-managed permissions are created in the management
account, including stack sets that are created by delegated administrators.
- `"Capabilities"`: In some cases, you must explicitly acknowledge that your stack set
template contains certain capabilities in order for CloudFormation to create the stack set
and related stack instances. CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack
templates might include resources that can affect permissions in your Amazon Web Services
account; for example, by creating new Identity and Access Management (IAM) users. For those
stack sets, you must explicitly acknowledge this by specifying one of these capabilities.
The following IAM resources require you to specify either the CAPABILITY_IAM or
CAPABILITY_NAMED_IAM capability. If you have IAM resources, you can specify either
capability. If you have IAM resources with custom names, you must specify
CAPABILITY_NAMED_IAM. If you don't specify either of these capabilities, CloudFormation
returns an InsufficientCapabilities error. If your stack template contains these
resources, we recommend that you review all permissions associated with them and edit their
permissions if necessary. AWS::IAM::AccessKey AWS::IAM::Group
AWS::IAM::InstanceProfile AWS::IAM::Policy AWS::IAM::Role AWS::IAM::User
AWS::IAM::UserToGroupAddition For more information, see Acknowledging IAM Resources in
CloudFormation Templates. CAPABILITY_AUTO_EXPAND Some templates reference macros. If
your stack set template references one or more macros, you must create the stack set
directly from the processed template, without first reviewing the resulting changes in a
change set. To create the stack set directly, you must acknowledge this capability. For
more information, see Using CloudFormation Macros to Perform Custom Processing on
Templates. Stack sets with service-managed permissions don't currently support the use of
macros in templates. (This includes the AWS::Include and AWS::Serverless transforms, which
are macros hosted by CloudFormation.) Even if you specify this capability for a stack set
with service-managed permissions, if you reference a macro in your template the stack set
operation will fail.
- `"ClientRequestToken"`: A unique identifier for this CreateStackSet request. Specify this
token if you plan to retry requests so that CloudFormation knows that you're not attempting
to create another stack set with the same name. You might retry CreateStackSet requests to
ensure that CloudFormation successfully received them. If you don't specify an operation
ID, the SDK generates one automatically.
- `"Description"`: A description of the stack set. You can use the description to identify
the stack set's purpose or other important information.
- `"ExecutionRoleName"`: The name of the IAM execution role to use to create the stack set.
If you do not specify an execution role, CloudFormation uses the
AWSCloudFormationStackSetExecutionRole role for the stack set operation. Specify an IAM
role only if you are using customized execution roles to control which stack resources
users and groups can include in their stack sets.
- `"ManagedExecution"`: Describes whether StackSets performs non-conflicting operations
concurrently and queues conflicting operations.
- `"Parameters"`: The input parameters for the stack set template.
- `"PermissionModel"`: Describes how the IAM roles required for stack set operations are
created. By default, SELF-MANAGED is specified. With self-managed permissions, you must
create the administrator and execution roles required to deploy to target accounts. For
more information, see Grant Self-Managed Stack Set Permissions. With service-managed
permissions, StackSets automatically creates the IAM roles required to deploy to accounts
managed by Organizations. For more information, see Grant Service-Managed Stack Set
Permissions.
- `"StackId"`: The stack ID you are importing into a new stack set. Specify the Amazon
Resource Name (ARN) of the stack.
- `"Tags"`: The key-value pairs to associate with this stack set and the stacks created
from it. CloudFormation also propagates these tags to supported resources that are created
in the stacks. A maximum number of 50 tags can be specified. If you specify tags as part of
a CreateStackSet action, CloudFormation checks to see if you have the required IAM
permission to tag resources. If you don't, the entire CreateStackSet action fails with an
access denied error, and the stack set is not created.
- `"TemplateBody"`: The structure that contains the template body, with a minimum length of
1 byte and a maximum length of 51,200 bytes. For more information, see Template Anatomy in
the CloudFormation User Guide. Conditional: You must specify either the TemplateBody or the
TemplateURL parameter, but not both.
- `"TemplateURL"`: The location of the file that contains the template body. The URL must
point to a template (maximum size: 460,800 bytes) that's located in an Amazon S3 bucket or
a Systems Manager document. For more information, see Template Anatomy in the
CloudFormation User Guide. Conditional: You must specify either the TemplateBody or the
TemplateURL parameter, but not both.
"""
function create_stack_set(StackSetName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"CreateStackSet",
Dict{String,Any}(
"StackSetName" => StackSetName, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_stack_set(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"CreateStackSet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StackSetName" => StackSetName, "ClientRequestToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deactivate_organizations_access()
deactivate_organizations_access(params::Dict{String,<:Any})
Deactivates trusted access with Organizations. If trusted access is deactivated, the
management account does not have permissions to create and manage service-managed StackSets
for your organization.
"""
function deactivate_organizations_access(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeactivateOrganizationsAccess";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deactivate_organizations_access(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeactivateOrganizationsAccess",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deactivate_type()
deactivate_type(params::Dict{String,<:Any})
Deactivates a public extension that was previously activated in this account and Region.
Once deactivated, an extension can't be used in any CloudFormation operation. This includes
stack update operations where the stack template includes the extension, even if no updates
are being made to the extension. In addition, deactivated extensions aren't automatically
updated if a new version of the extension is released.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) for the extension, in this account and Region.
Conditional: You must specify either Arn, or TypeName and Type.
- `"Type"`: The extension type. Conditional: You must specify either Arn, or TypeName and
Type.
- `"TypeName"`: The type name of the extension, in this account and Region. If you
specified a type name alias when enabling the extension, use the type name alias.
Conditional: You must specify either Arn, or TypeName and Type.
"""
function deactivate_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DeactivateType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function deactivate_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeactivateType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
delete_change_set(change_set_name)
delete_change_set(change_set_name, params::Dict{String,<:Any})
Deletes the specified change set. Deleting change sets ensures that no one executes the
wrong change set. If the call successfully completes, CloudFormation successfully deleted
the change set. If IncludeNestedStacks specifies True during the creation of the nested
change set, then DeleteChangeSet will delete all change sets that belong to the stacks
hierarchy and will also delete all change sets for nested stacks with the status of
REVIEW_IN_PROGRESS.
# Arguments
- `change_set_name`: The name or Amazon Resource Name (ARN) of the change set that you want
to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StackName"`: If you specified the name of a change set to delete, specify the stack
name or Amazon Resource Name (ARN) that's associated with it.
"""
function delete_change_set(ChangeSetName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DeleteChangeSet",
Dict{String,Any}("ChangeSetName" => ChangeSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_change_set(
ChangeSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DeleteChangeSet",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ChangeSetName" => ChangeSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_generated_template(generated_template_name)
delete_generated_template(generated_template_name, params::Dict{String,<:Any})
Deleted a generated template.
# Arguments
- `generated_template_name`: The name or Amazon Resource Name (ARN) of a generated template.
"""
function delete_generated_template(
GeneratedTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeleteGeneratedTemplate",
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_generated_template(
GeneratedTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DeleteGeneratedTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stack(stack_name)
delete_stack(stack_name, params::Dict{String,<:Any})
Deletes a specified stack. Once the call completes successfully, stack deletion starts.
Deleted stacks don't show up in the DescribeStacks operation if the deletion has been
completed successfully.
# Arguments
- `stack_name`: The name or the unique stack ID that's associated with the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this DeleteStack request. Specify this
token if you plan to retry requests so that CloudFormation knows that you're not attempting
to delete a stack with the same name. You might retry DeleteStack requests to ensure that
CloudFormation successfully received them. All events initiated by a given stack operation
are assigned the same client request token, which you can use to track operations. For
example, if you execute a CreateStack operation with the token token1, then all the
StackEvents generated by that operation will have ClientRequestToken set as token1. In the
console, stack operations display the client request token on the Events tab. Stack
operations that are initiated from the console use the token format
Console-StackOperation-ID, which helps you easily identify the stack operation . For
example, if you create a stack using the console, each stack event would be assigned the
same token in the following format:
Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002.
- `"DeletionMode"`: Specifies the deletion mode for the stack. Possible values are:
STANDARD - Use the standard behavior. Specifying this value is the same as not specifying
this parameter. FORCE_DELETE_STACK - Delete the stack if it's stuck in a DELETE_FAILED
state due to resource deletion failure.
- `"RetainResources"`: For stacks in the DELETE_FAILED state, a list of resource logical
IDs that are associated with the resources you want to retain. During deletion,
CloudFormation deletes the stack but doesn't delete the retained resources. Retaining
resources is useful when you can't delete a resource, such as a non-empty S3 bucket, but
you want to delete the stack.
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management (IAM)
role that CloudFormation assumes to delete the stack. CloudFormation uses the role's
credentials to make calls on your behalf. If you don't specify a value, CloudFormation uses
the role that was previously associated with the stack. If no role is available,
CloudFormation uses a temporary session that's generated from your user credentials.
"""
function delete_stack(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DeleteStack",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stack(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DeleteStack",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stack_instances(regions, retain_stacks, stack_set_name)
delete_stack_instances(regions, retain_stacks, stack_set_name, params::Dict{String,<:Any})
Deletes stack instances for the specified accounts, in the specified Amazon Web Services
Regions.
# Arguments
- `regions`: The Amazon Web Services Regions where you want to delete stack set instances.
- `retain_stacks`: Removes the stack instances from the specified stack set, but doesn't
delete the stacks. You can't reassociate a retained stack or add an existing, saved stack
to a new stack set. For more information, see Stack set operation options.
- `stack_set_name`: The name or unique ID of the stack set that you want to delete stack
instances for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accounts"`: [Self-managed permissions] The names of the Amazon Web Services accounts
that you want to delete stack instances for. You can specify Accounts or DeploymentTargets,
but not both.
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"DeploymentTargets"`: [Service-managed permissions] The Organizations accounts from
which to delete stack instances. You can specify Accounts or DeploymentTargets, but not
both.
- `"OperationId"`: The unique identifier for this stack set operation. If you don't specify
an operation ID, the SDK generates one automatically. The operation ID also functions as an
idempotency token, to ensure that CloudFormation performs the stack set operation only
once, even if you retry the request multiple times. You can retry stack set operation
requests to ensure that CloudFormation successfully received them. Repeating this stack set
operation with a new operation ID retries all stack instances whose status is OUTDATED.
- `"OperationPreferences"`: Preferences for how CloudFormation performs this stack set
operation.
"""
function delete_stack_instances(
Regions, RetainStacks, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeleteStackInstances",
Dict{String,Any}(
"Regions" => Regions,
"RetainStacks" => RetainStacks,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stack_instances(
Regions,
RetainStacks,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DeleteStackInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Regions" => Regions,
"RetainStacks" => RetainStacks,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_stack_set(stack_set_name)
delete_stack_set(stack_set_name, params::Dict{String,<:Any})
Deletes a stack set. Before you can delete a stack set, all its member stack instances must
be deleted. For more information about how to complete this, see DeleteStackInstances.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set that you're deleting. You can
obtain this value by running ListStackSets.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
"""
function delete_stack_set(StackSetName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DeleteStackSet",
Dict{String,Any}("StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_stack_set(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DeleteStackSet",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackSetName" => StackSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_type()
deregister_type(params::Dict{String,<:Any})
Marks an extension or extension version as DEPRECATED in the CloudFormation registry,
removing it from active use. Deprecated extensions or extension versions cannot be used in
CloudFormation operations. To deregister an entire extension, you must individually
deregister all active versions of that extension. If an extension has only a single active
version, deregistering that version results in the extension itself being deregistered and
marked as deprecated in the registry. You can't deregister the default version of an
extension if there are other active version of that extension. If you do deregister the
default version of an extension, the extension type itself is deregistered as well and
marked as deprecated. To view the deprecation status of an extension or extension version,
use DescribeType.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension. Conditional: You must specify
either TypeName and Type, or Arn.
- `"Type"`: The kind of extension. Conditional: You must specify either TypeName and Type,
or Arn.
- `"TypeName"`: The name of the extension. Conditional: You must specify either TypeName
and Type, or Arn.
- `"VersionId"`: The ID of a specific version of the extension. The version ID is the value
at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is
registered.
"""
function deregister_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DeregisterType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function deregister_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DeregisterType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_account_limits()
describe_account_limits(params::Dict{String,<:Any})
Retrieves your account's CloudFormation limits, such as the maximum number of stacks that
you can create in your account. For more information about account limits, see
CloudFormation Quotas in the CloudFormation User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string that identifies the next page of limits that you want to retrieve.
"""
function describe_account_limits(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeAccountLimits"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_account_limits(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeAccountLimits",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_change_set(change_set_name)
describe_change_set(change_set_name, params::Dict{String,<:Any})
Returns the inputs for the change set and a list of changes that CloudFormation will make
if you execute the change set. For more information, see Updating Stacks Using Change Sets
in the CloudFormation User Guide.
# Arguments
- `change_set_name`: The name or Amazon Resource Name (ARN) of the change set that you want
to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IncludePropertyValues"`: If true, the returned changes include detailed changes in the
property values.
- `"NextToken"`: A string (provided by the DescribeChangeSet response output) that
identifies the next page of information that you want to retrieve.
- `"StackName"`: If you specified the name of a change set, specify the stack name or ID
(ARN) of the change set you want to describe.
"""
function describe_change_set(
ChangeSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeChangeSet",
Dict{String,Any}("ChangeSetName" => ChangeSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_change_set(
ChangeSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeChangeSet",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ChangeSetName" => ChangeSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_change_set_hooks(change_set_name)
describe_change_set_hooks(change_set_name, params::Dict{String,<:Any})
Returns hook-related information for the change set and a list of changes that
CloudFormation makes when you run the change set.
# Arguments
- `change_set_name`: The name or Amazon Resource Name (ARN) of the change set that you want
to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LogicalResourceId"`: If specified, lists only the hooks related to the specified
LogicalResourceId.
- `"NextToken"`: A string, provided by the DescribeChangeSetHooks response output, that
identifies the next page of information that you want to retrieve.
- `"StackName"`: If you specified the name of a change set, specify the stack name or stack
ID (ARN) of the change set you want to describe.
"""
function describe_change_set_hooks(
ChangeSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeChangeSetHooks",
Dict{String,Any}("ChangeSetName" => ChangeSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_change_set_hooks(
ChangeSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeChangeSetHooks",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ChangeSetName" => ChangeSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_generated_template(generated_template_name)
describe_generated_template(generated_template_name, params::Dict{String,<:Any})
Describes a generated template. The output includes details about the progress of the
creation of a generated template started by a CreateGeneratedTemplate API action or the
update of a generated template started with an UpdateGeneratedTemplate API action.
# Arguments
- `generated_template_name`: The name or Amazon Resource Name (ARN) of a generated template.
"""
function describe_generated_template(
GeneratedTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeGeneratedTemplate",
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_generated_template(
GeneratedTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeGeneratedTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_organizations_access()
describe_organizations_access(params::Dict{String,<:Any})
Retrieves information about the account's OrganizationAccess status. This API can be called
either by the management account or the delegated administrator by using the CallAs
parameter. This API can also be called without the CallAs parameter by the management
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. If you are signed in to the management
account, specify SELF. If you are signed in to a delegated administrator account, specify
DELEGATED_ADMIN. Your Amazon Web Services account must be registered as a delegated
administrator in the management account. For more information, see Register a delegated
administrator in the CloudFormation User Guide.
"""
function describe_organizations_access(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeOrganizationsAccess";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_organizations_access(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeOrganizationsAccess",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_publisher()
describe_publisher(params::Dict{String,<:Any})
Returns information about a CloudFormation extension publisher. If you don't supply a
PublisherId, and you have registered as an extension publisher, DescribePublisher returns
information about your own publisher account. For more information about registering as a
publisher, see: RegisterPublisher Publishing extensions to make them available for
public use in the CloudFormation CLI User Guide
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PublisherId"`: The ID of the extension publisher. If you don't supply a PublisherId,
and you have registered as an extension publisher, DescribePublisher returns information
about your own publisher account.
"""
function describe_publisher(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribePublisher"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_publisher(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribePublisher", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_resource_scan(resource_scan_id)
describe_resource_scan(resource_scan_id, params::Dict{String,<:Any})
Describes details of a resource scan.
# Arguments
- `resource_scan_id`: The Amazon Resource Name (ARN) of the resource scan.
"""
function describe_resource_scan(
ResourceScanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeResourceScan",
Dict{String,Any}("ResourceScanId" => ResourceScanId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_resource_scan(
ResourceScanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeResourceScan",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceScanId" => ResourceScanId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_drift_detection_status(stack_drift_detection_id)
describe_stack_drift_detection_status(stack_drift_detection_id, params::Dict{String,<:Any})
Returns information about a stack drift detection operation. A stack drift detection
operation detects whether a stack's actual configuration differs, or has drifted, from its
expected configuration, as defined in the stack template and any values specified as
template parameters. A stack is considered to have drifted if one or more of its resources
have drifted. For more information about stack and resource drift, see Detecting
Unregulated Configuration Changes to Stacks and Resources. Use DetectStackDrift to initiate
a stack drift detection operation. DetectStackDrift returns a StackDriftDetectionId you can
use to monitor the progress of the operation using DescribeStackDriftDetectionStatus. Once
the drift detection operation has completed, use DescribeStackResourceDrifts to return
drift information about the stack and its resources.
# Arguments
- `stack_drift_detection_id`: The ID of the drift detection results of this operation.
CloudFormation generates new results, with a new drift detection ID, each time this
operation is run. However, the number of drift results CloudFormation retains for any given
stack, and for how long, may vary.
"""
function describe_stack_drift_detection_status(
StackDriftDetectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackDriftDetectionStatus",
Dict{String,Any}("StackDriftDetectionId" => StackDriftDetectionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_drift_detection_status(
StackDriftDetectionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackDriftDetectionStatus",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("StackDriftDetectionId" => StackDriftDetectionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_events()
describe_stack_events(params::Dict{String,<:Any})
Returns all stack related events for a specified stack in reverse chronological order. For
more information about a stack's event history, see CloudFormation stack creation events in
the CloudFormation User Guide. You can list events for stacks that have failed to create
or have been deleted by specifying the unique stack identifier (stack ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string that identifies the next page of events that you want to retrieve.
- `"StackName"`: The name or the unique stack ID that's associated with the stack, which
aren't always interchangeable: Running stacks: You can specify either the stack's name or
its unique stack ID. Deleted stacks: You must specify the unique stack ID. Default:
There is no default value.
"""
function describe_stack_events(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeStackEvents"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_stack_events(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackEvents",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_instance(stack_instance_account, stack_instance_region, stack_set_name)
describe_stack_instance(stack_instance_account, stack_instance_region, stack_set_name, params::Dict{String,<:Any})
Returns the stack instance that's associated with the specified StackSet, Amazon Web
Services account, and Amazon Web Services Region. For a list of stack instances that are
associated with a specific StackSet, use ListStackInstances.
# Arguments
- `stack_instance_account`: The ID of an Amazon Web Services account that's associated with
this stack instance.
- `stack_instance_region`: The name of a Region that's associated with this stack instance.
- `stack_set_name`: The name or the unique stack ID of the stack set that you want to get
stack instance information for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
"""
function describe_stack_instance(
StackInstanceAccount,
StackInstanceRegion,
StackSetName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackInstance",
Dict{String,Any}(
"StackInstanceAccount" => StackInstanceAccount,
"StackInstanceRegion" => StackInstanceRegion,
"StackSetName" => StackSetName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_instance(
StackInstanceAccount,
StackInstanceRegion,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackInstance",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StackInstanceAccount" => StackInstanceAccount,
"StackInstanceRegion" => StackInstanceRegion,
"StackSetName" => StackSetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_resource(logical_resource_id, stack_name)
describe_stack_resource(logical_resource_id, stack_name, params::Dict{String,<:Any})
Returns a description of the specified resource in the specified stack. For deleted stacks,
DescribeStackResource returns resource information for up to 90 days after the stack has
been deleted.
# Arguments
- `logical_resource_id`: The logical name of the resource as specified in the template.
Default: There is no default value.
- `stack_name`: The name or the unique stack ID that's associated with the stack, which
aren't always interchangeable: Running stacks: You can specify either the stack's name or
its unique stack ID. Deleted stacks: You must specify the unique stack ID. Default:
There is no default value.
"""
function describe_stack_resource(
LogicalResourceId, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackResource",
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId, "StackName" => StackName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_resource(
LogicalResourceId,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId, "StackName" => StackName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_resource_drifts(stack_name)
describe_stack_resource_drifts(stack_name, params::Dict{String,<:Any})
Returns drift information for the resources that have been checked for drift in the
specified stack. This includes actual and expected configuration values for resources where
CloudFormation detects configuration drift. For a given stack, there will be one
StackResourceDrift for each stack resource that has been checked for drift. Resources that
haven't yet been checked for drift aren't included. Resources that don't currently support
drift detection aren't checked, and so not included. For a list of resources that support
drift detection, see Resources that Support Drift Detection. Use DetectStackResourceDrift
to detect drift on individual resources, or DetectStackDrift to detect drift on all
supported resources for a given stack.
# Arguments
- `stack_name`: The name of the stack for which you want drift information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: A string that identifies the next page of stack resource drift results.
- `"StackResourceDriftStatusFilters"`: The resource drift status values to use as filters
for the resource drift results returned. DELETED: The resource differs from its expected
template configuration in that the resource has been deleted. MODIFIED: One or more
resource properties differ from their expected template values. IN_SYNC: The resource's
actual configuration matches its expected template configuration. NOT_CHECKED:
CloudFormation doesn't currently return this value.
"""
function describe_stack_resource_drifts(
StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackResourceDrifts",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_resource_drifts(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackResourceDrifts",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_resources()
describe_stack_resources(params::Dict{String,<:Any})
Returns Amazon Web Services resource descriptions for running and deleted stacks. If
StackName is specified, all the associated resources that are part of the stack are
returned. If PhysicalResourceId is specified, the associated resources of the stack that
the resource belongs to are returned. Only the first 100 resources will be returned. If
your stack has more resources than this, you should use ListStackResources instead. For
deleted stacks, DescribeStackResources returns resource information for up to 90 days after
the stack has been deleted. You must specify either StackName or PhysicalResourceId, but
not both. In addition, you can specify LogicalResourceId to filter the returned result. For
more information about resources, the LogicalResourceId and PhysicalResourceId, go to the
CloudFormation User Guide. A ValidationError is returned if you specify both StackName and
PhysicalResourceId in the same request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LogicalResourceId"`: The logical name of the resource as specified in the template.
Default: There is no default value.
- `"PhysicalResourceId"`: The name or unique identifier that corresponds to a physical
instance ID of a resource supported by CloudFormation. For example, for an Amazon Elastic
Compute Cloud (EC2) instance, PhysicalResourceId corresponds to the InstanceId. You can
pass the EC2 InstanceId to DescribeStackResources to find which stack the instance belongs
to and what other resources are part of the stack. Required: Conditional. If you don't
specify PhysicalResourceId, you must specify StackName. Default: There is no default value.
- `"StackName"`: The name or the unique stack ID that is associated with the stack, which
aren't always interchangeable: Running stacks: You can specify either the stack's name or
its unique stack ID. Deleted stacks: You must specify the unique stack ID. Default:
There is no default value. Required: Conditional. If you don't specify StackName, you must
specify PhysicalResourceId.
"""
function describe_stack_resources(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeStackResources"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_stack_resources(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackResources",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_set(stack_set_name)
describe_stack_set(stack_set_name, params::Dict{String,<:Any})
Returns the description of the specified StackSet.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set whose description you want.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
"""
function describe_stack_set(StackSetName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeStackSet",
Dict{String,Any}("StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_set(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackSet",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackSetName" => StackSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stack_set_operation(operation_id, stack_set_name)
describe_stack_set_operation(operation_id, stack_set_name, params::Dict{String,<:Any})
Returns the description of the specified StackSet operation.
# Arguments
- `operation_id`: The unique ID of the stack set operation.
- `stack_set_name`: The name or the unique stack ID of the stack set for the stack
operation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
"""
function describe_stack_set_operation(
OperationId, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStackSetOperation",
Dict{String,Any}("OperationId" => OperationId, "StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_stack_set_operation(
OperationId,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeStackSetOperation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"OperationId" => OperationId, "StackSetName" => StackSetName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_stacks()
describe_stacks(params::Dict{String,<:Any})
Returns the description for the specified stack; if no stack name was specified, then it
returns the description for all the stacks created. For more information about a stack's
event history, see CloudFormation stack creation events in the CloudFormation User Guide.
If the stack doesn't exist, a ValidationError is returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string that identifies the next page of stacks that you want to retrieve.
- `"StackName"`: If you don't pass a parameter to StackName, the API returns a response
that describes all resources in the account, which can impact performance. This requires
ListStacks and DescribeStacks permissions. Consider using the ListStacks API if you're not
passing a parameter to StackName. The IAM policy below can be added to IAM policies when
you want to limit resource-level permissions and avoid returning a response when no
parameter is sent in the request: { \"Version\": \"2012-10-17\", \"Statement\": [{
\"Effect\": \"Deny\", \"Action\": \"cloudformation:DescribeStacks\", \"NotResource\":
\"arn:aws:cloudformation:*:*:stack/*/*\" }] } The name or the unique stack ID that's
associated with the stack, which aren't always interchangeable: Running stacks: You can
specify either the stack's name or its unique stack ID. Deleted stacks: You must specify
the unique stack ID. Default: There is no default value.
"""
function describe_stacks(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeStacks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_stacks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeStacks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_type()
describe_type(params::Dict{String,<:Any})
Returns detailed information about an extension that has been registered. If you specify a
VersionId, DescribeType returns information about that specific extension version.
Otherwise, it returns information about the default extension version.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension. Conditional: You must specify
either TypeName and Type, or Arn.
- `"PublicVersionNumber"`: The version number of a public third-party extension.
- `"PublisherId"`: The publisher ID of the extension publisher. Extensions provided by
Amazon Web Services are not assigned a publisher ID.
- `"Type"`: The kind of extension. Conditional: You must specify either TypeName and Type,
or Arn.
- `"TypeName"`: The name of the extension. Conditional: You must specify either TypeName
and Type, or Arn.
- `"VersionId"`: The ID of a specific version of the extension. The version ID is the value
at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is
registered. If you specify a VersionId, DescribeType returns information about that
specific extension version. Otherwise, it returns information about the default extension
version.
"""
function describe_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DescribeType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_type_registration(registration_token)
describe_type_registration(registration_token, params::Dict{String,<:Any})
Returns information about an extension's registration, including its current status and
type and version identifiers. When you initiate a registration request using RegisterType,
you can then use DescribeTypeRegistration to monitor the progress of that registration
request. Once the registration request has completed, use DescribeType to return detailed
information about an extension.
# Arguments
- `registration_token`: The identifier for this registration request. This registration
token is generated by CloudFormation when you initiate a registration request using
RegisterType.
"""
function describe_type_registration(
RegistrationToken; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DescribeTypeRegistration",
Dict{String,Any}("RegistrationToken" => RegistrationToken);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_type_registration(
RegistrationToken,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DescribeTypeRegistration",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RegistrationToken" => RegistrationToken), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detect_stack_drift(stack_name)
detect_stack_drift(stack_name, params::Dict{String,<:Any})
Detects whether a stack's actual configuration differs, or has drifted, from its expected
configuration, as defined in the stack template and any values specified as template
parameters. For each resource in the stack that supports drift detection, CloudFormation
compares the actual configuration of the resource with its expected template configuration.
Only resource properties explicitly defined in the stack template are checked for drift. A
stack is considered to have drifted if one or more of its resources differ from their
expected template configurations. For more information, see Detecting Unregulated
Configuration Changes to Stacks and Resources. Use DetectStackDrift to detect drift on all
supported resources for a given stack, or DetectStackResourceDrift to detect drift on
individual resources. For a list of stack resources that currently support drift detection,
see Resources that Support Drift Detection. DetectStackDrift can take up to several
minutes, depending on the number of resources contained within the stack. Use
DescribeStackDriftDetectionStatus to monitor the progress of a detect stack drift
operation. Once the drift detection operation has completed, use
DescribeStackResourceDrifts to return drift information about the stack and its resources.
When detecting drift on a stack, CloudFormation doesn't detect drift on any nested stacks
belonging to that stack. Perform DetectStackDrift directly on the nested stack itself.
# Arguments
- `stack_name`: The name of the stack for which you want to detect drift.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LogicalResourceIds"`: The logical names of any resources you want to use as filters.
"""
function detect_stack_drift(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"DetectStackDrift",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detect_stack_drift(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DetectStackDrift",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detect_stack_resource_drift(logical_resource_id, stack_name)
detect_stack_resource_drift(logical_resource_id, stack_name, params::Dict{String,<:Any})
Returns information about whether a resource's actual configuration differs, or has
drifted, from its expected configuration, as defined in the stack template and any values
specified as template parameters. This information includes actual and expected property
values for resources in which CloudFormation detects drift. Only resource properties
explicitly defined in the stack template are checked for drift. For more information about
stack and resource drift, see Detecting Unregulated Configuration Changes to Stacks and
Resources. Use DetectStackResourceDrift to detect drift on individual resources, or
DetectStackDrift to detect drift on all resources in a given stack that support drift
detection. Resources that don't currently support drift detection can't be checked. For a
list of resources that support drift detection, see Resources that Support Drift Detection.
# Arguments
- `logical_resource_id`: The logical name of the resource for which to return drift
information.
- `stack_name`: The name of the stack to which the resource belongs.
"""
function detect_stack_resource_drift(
LogicalResourceId, StackName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DetectStackResourceDrift",
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId, "StackName" => StackName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detect_stack_resource_drift(
LogicalResourceId,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DetectStackResourceDrift",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId, "StackName" => StackName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
detect_stack_set_drift(stack_set_name)
detect_stack_set_drift(stack_set_name, params::Dict{String,<:Any})
Detect drift on a stack set. When CloudFormation performs drift detection on a stack set,
it performs drift detection on the stack associated with each stack instance in the stack
set. For more information, see How CloudFormation performs drift detection on a stack set.
DetectStackSetDrift returns the OperationId of the stack set drift detection operation. Use
this operation id with DescribeStackSetOperation to monitor the progress of the drift
detection operation. The drift detection operation may take some time, depending on the
number of stack instances included in the stack set, in addition to the number of resources
included in each stack. Once the operation has completed, use the following actions to
return drift information: Use DescribeStackSet to return detailed information about the
stack set, including detailed information about the last completed drift operation
performed on the stack set. (Information about drift operations that are in progress isn't
included.) Use ListStackInstances to return a list of stack instances belonging to the
stack set, including the drift status and last drift time checked of each instance. Use
DescribeStackInstance to return detailed information about a specific stack instance,
including its drift status and last drift time checked. For more information about
performing a drift detection operation on a stack set, see Detecting unmanaged changes in
stack sets. You can only run a single drift detection operation on a given stack set at one
time. To stop a drift detection stack set operation, use StopStackSetOperation.
# Arguments
- `stack_set_name`: The name of the stack set on which to perform the drift detection
operation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"OperationId"`: The ID of the stack set operation.
- `"OperationPreferences"`: The user-specified preferences for how CloudFormation performs
a stack set operation. For more information about maximum concurrent accounts and failure
tolerance, see Stack set operation options.
"""
function detect_stack_set_drift(
StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"DetectStackSetDrift",
Dict{String,Any}("StackSetName" => StackSetName, "OperationId" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function detect_stack_set_drift(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"DetectStackSetDrift",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StackSetName" => StackSetName, "OperationId" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
estimate_template_cost()
estimate_template_cost(params::Dict{String,<:Any})
Returns the estimated monthly cost of a template. The return value is an Amazon Web
Services Simple Monthly Calculator URL with a query string that describes the resources
required to run the template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Parameters"`: A list of Parameter structures that specify input parameters.
- `"TemplateBody"`: Structure containing the template body with a minimum length of 1 byte
and a maximum length of 51,200 bytes. (For more information, go to Template Anatomy in the
CloudFormation User Guide.) Conditional: You must pass TemplateBody or TemplateURL. If both
are passed, only TemplateBody is used.
- `"TemplateURL"`: Location of file containing the template body. The URL must point to a
template that's located in an Amazon S3 bucket or a Systems Manager document. For more
information, go to Template Anatomy in the CloudFormation User Guide. The location for an
Amazon S3 bucket must start with https://. Conditional: You must pass TemplateURL or
TemplateBody. If both are passed, only TemplateBody is used.
"""
function estimate_template_cost(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"EstimateTemplateCost"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function estimate_template_cost(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"EstimateTemplateCost",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
execute_change_set(change_set_name)
execute_change_set(change_set_name, params::Dict{String,<:Any})
Updates a stack using the input information that was provided when the specified change set
was created. After the call successfully completes, CloudFormation starts updating the
stack. Use the DescribeStacks action to view the status of the update. When you execute a
change set, CloudFormation deletes all other change sets associated with the stack because
they aren't valid for the updated stack. If a stack policy is associated with the stack,
CloudFormation enforces the policy during the update. You can't specify a temporary stack
policy that overrides the current policy. To create a change set for the entire stack
hierarchy, IncludeNestedStacks must have been set to True.
# Arguments
- `change_set_name`: The name or Amazon Resource Name (ARN) of the change set that you want
use to update the specified stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this ExecuteChangeSet request. Specify
this token if you plan to retry requests so that CloudFormation knows that you're not
attempting to execute a change set to update a stack with the same name. You might retry
ExecuteChangeSet requests to ensure that CloudFormation successfully received them.
- `"DisableRollback"`: Preserves the state of previously provisioned resources when an
operation fails. This parameter can't be specified when the OnStackFailure parameter to the
CreateChangeSet API operation was specified. True - if the stack creation fails, do
nothing. This is equivalent to specifying DO_NOTHING for the OnStackFailure parameter to
the CreateChangeSet API operation. False - if the stack creation fails, roll back the
stack. This is equivalent to specifying ROLLBACK for the OnStackFailure parameter to the
CreateChangeSet API operation. Default: True
- `"RetainExceptOnCreate"`: When set to true, newly created resources are deleted when the
operation rolls back. This includes newly created resources marked with a deletion policy
of Retain. Default: false
- `"StackName"`: If you specified the name of a change set, specify the stack name or
Amazon Resource Name (ARN) that's associated with the change set you want to execute.
"""
function execute_change_set(
ChangeSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ExecuteChangeSet",
Dict{String,Any}("ChangeSetName" => ChangeSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function execute_change_set(
ChangeSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ExecuteChangeSet",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ChangeSetName" => ChangeSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_generated_template(generated_template_name)
get_generated_template(generated_template_name, params::Dict{String,<:Any})
Retrieves a generated template. If the template is in an InProgress or Pending status then
the template returned will be the template when the template was last in a Complete status.
If the template has not yet been in a Complete status then an empty template will be
returned.
# Arguments
- `generated_template_name`: The name or Amazon Resource Name (ARN) of the generated
template. The format is
arn:{Partition}:cloudformation:{Region}:{Account}:generatedtemplate/{Id}. For example,
arn:aws:cloudformation:us-east-1:123456789012:generatedtemplate/2e8465c1-9a80-43ea-a3a3-4f2d
692fe6dc .
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Format"`: The language to use to retrieve for the generated template. Supported values
are: JSON YAML
"""
function get_generated_template(
GeneratedTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"GetGeneratedTemplate",
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_generated_template(
GeneratedTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"GetGeneratedTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_stack_policy(stack_name)
get_stack_policy(stack_name, params::Dict{String,<:Any})
Returns the stack policy for a specified stack. If a stack doesn't have a policy, a null
value is returned.
# Arguments
- `stack_name`: The name or unique stack ID that's associated with the stack whose policy
you want to get.
"""
function get_stack_policy(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"GetStackPolicy",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_stack_policy(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"GetStackPolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_template()
get_template(params::Dict{String,<:Any})
Returns the template body for a specified stack. You can get the template for running or
deleted stacks. For deleted stacks, GetTemplate returns the template for up to 90 days
after the stack has been deleted. If the template doesn't exist, a ValidationError is
returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChangeSetName"`: The name or Amazon Resource Name (ARN) of a change set for which
CloudFormation returns the associated template. If you specify a name, you must also
specify the StackName.
- `"StackName"`: The name or the unique stack ID that's associated with the stack, which
aren't always interchangeable: Running stacks: You can specify either the stack's name or
its unique stack ID. Deleted stacks: You must specify the unique stack ID. Default:
There is no default value.
- `"TemplateStage"`: For templates that include transforms, the stage of the template that
CloudFormation returns. To get the user-submitted template, specify Original. To get the
template after CloudFormation has processed all transforms, specify Processed. If the
template doesn't include transforms, Original and Processed return the same template. By
default, CloudFormation specifies Processed.
"""
function get_template(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"GetTemplate"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_template(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"GetTemplate", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_template_summary()
get_template_summary(params::Dict{String,<:Any})
Returns information about a new or existing template. The GetTemplateSummary action is
useful for viewing parameter information, such as default parameter values and parameter
types, before you create or update a stack or stack set. You can use the GetTemplateSummary
action when you submit a template, or you can get template information for a stack set, or
a running or deleted stack. For deleted stacks, GetTemplateSummary returns the template
information for up to 90 days after the stack has been deleted. If the template doesn't
exist, a ValidationError is returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"StackName"`: The name or the stack ID that's associated with the stack, which aren't
always interchangeable. For running stacks, you can specify either the stack's name or its
unique stack ID. For deleted stack, you must specify the unique stack ID. Conditional: You
must specify only one of the following parameters: StackName, StackSetName, TemplateBody,
or TemplateURL.
- `"StackSetName"`: The name or unique ID of the stack set from which the stack was
created. Conditional: You must specify only one of the following parameters: StackName,
StackSetName, TemplateBody, or TemplateURL.
- `"TemplateBody"`: Structure containing the template body with a minimum length of 1 byte
and a maximum length of 51,200 bytes. For more information about templates, see Template
anatomy in the CloudFormation User Guide. Conditional: You must specify only one of the
following parameters: StackName, StackSetName, TemplateBody, or TemplateURL.
- `"TemplateSummaryConfig"`: Specifies options for the GetTemplateSummary API action.
- `"TemplateURL"`: Location of file containing the template body. The URL must point to a
template (max size: 460,800 bytes) that's located in an Amazon S3 bucket or a Systems
Manager document. For more information about templates, see Template anatomy in the
CloudFormation User Guide. The location for an Amazon S3 bucket must start with https://.
Conditional: You must specify only one of the following parameters: StackName,
StackSetName, TemplateBody, or TemplateURL.
"""
function get_template_summary(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"GetTemplateSummary"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_template_summary(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"GetTemplateSummary", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
import_stacks_to_stack_set(stack_set_name)
import_stacks_to_stack_set(stack_set_name, params::Dict{String,<:Any})
Import existing stacks into a new stack sets. Use the stack import operation to import up
to 10 stacks into a new stack set in the same account as the source stack or in a different
administrator account and Region, by specifying the stack ID of the stack you intend to
import.
# Arguments
- `stack_set_name`: The name of the stack set. The name must be unique in the Region where
you create your stack set.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. For service
managed stack sets, specify DELEGATED_ADMIN.
- `"OperationId"`: A unique, user defined, identifier for the stack set operation.
- `"OperationPreferences"`: The user-specified preferences for how CloudFormation performs
a stack set operation. For more information about maximum concurrent accounts and failure
tolerance, see Stack set operation options.
- `"OrganizationalUnitIds"`: The list of OU ID's to which the stacks being imported has to
be mapped as deployment target.
- `"StackIds"`: The IDs of the stacks you are importing into a stack set. You import up to
10 stacks per stack set at a time. Specify either StackIds or StackIdsUrl.
- `"StackIdsUrl"`: The Amazon S3 URL which contains list of stack ids to be inputted.
Specify either StackIds or StackIdsUrl.
"""
function import_stacks_to_stack_set(
StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ImportStacksToStackSet",
Dict{String,Any}("StackSetName" => StackSetName, "OperationId" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_stacks_to_stack_set(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ImportStacksToStackSet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StackSetName" => StackSetName, "OperationId" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_change_sets(stack_name)
list_change_sets(stack_name, params::Dict{String,<:Any})
Returns the ID and status of each active change set for a stack. For example,
CloudFormation lists change sets that are in the CREATE_IN_PROGRESS or CREATE_PENDING state.
# Arguments
- `stack_name`: The name or the Amazon Resource Name (ARN) of the stack for which you want
to list change sets.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string (provided by the ListChangeSets response output) that identifies
the next page of change sets that you want to retrieve.
"""
function list_change_sets(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListChangeSets",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_change_sets(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListChangeSets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_exports()
list_exports(params::Dict{String,<:Any})
Lists all exported output values in the account and Region in which you call this action.
Use this action to see the exported output values that you can import into other stacks. To
import values, use the Fn::ImportValue function. For more information, see CloudFormation
export stack output values.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string (provided by the ListExports response output) that identifies the
next page of exported output values that you asked to retrieve.
"""
function list_exports(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListExports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_exports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListExports", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_generated_templates()
list_generated_templates(params::Dict{String,<:Any})
Lists your generated templates in this Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: If the number of available results exceeds this maximum, the response
includes a NextToken value that you can use for the NextToken parameter to get the next set
of results. By default the ListGeneratedTemplates API action will return at most 50 results
in each response. The maximum value is 100.
- `"NextToken"`: A string that identifies the next page of resource scan results.
"""
function list_generated_templates(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListGeneratedTemplates"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_generated_templates(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListGeneratedTemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_imports(export_name)
list_imports(export_name, params::Dict{String,<:Any})
Lists all stacks that are importing an exported output value. To modify or remove an
exported output value, first use this action to see which stacks are using it. To see the
exported output values in your account, see ListExports. For more information about
importing an exported output value, see the Fn::ImportValue function.
# Arguments
- `export_name`: The name of the exported output value. CloudFormation returns the stack
names that are importing this value.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string (provided by the ListImports response output) that identifies the
next page of stacks that are importing the specified exported output value.
"""
function list_imports(ExportName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListImports",
Dict{String,Any}("ExportName" => ExportName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_imports(
ExportName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListImports",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ExportName" => ExportName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resource_scan_related_resources(resource_scan_id, resources)
list_resource_scan_related_resources(resource_scan_id, resources, params::Dict{String,<:Any})
Lists the related resources for a list of resources from a resource scan. The response
indicates whether each returned resource is already managed by CloudFormation.
# Arguments
- `resource_scan_id`: The Amazon Resource Name (ARN) of the resource scan.
- `resources`: The list of resources for which you want to get the related resources. Up to
100 resources can be provided.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: If the number of available results exceeds this maximum, the response
includes a NextToken value that you can use for the NextToken parameter to get the next set
of results. By default the ListResourceScanRelatedResources API action will return up to
100 results in each response. The maximum value is 100.
- `"NextToken"`: A string that identifies the next page of resource scan results.
"""
function list_resource_scan_related_resources(
ResourceScanId, Resources; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListResourceScanRelatedResources",
Dict{String,Any}("ResourceScanId" => ResourceScanId, "Resources" => Resources);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resource_scan_related_resources(
ResourceScanId,
Resources,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListResourceScanRelatedResources",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceScanId" => ResourceScanId, "Resources" => Resources
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resource_scan_resources(resource_scan_id)
list_resource_scan_resources(resource_scan_id, params::Dict{String,<:Any})
Lists the resources from a resource scan. The results can be filtered by resource
identifier, resource type prefix, tag key, and tag value. Only resources that match all
specified filters are returned. The response indicates whether each returned resource is
already managed by CloudFormation.
# Arguments
- `resource_scan_id`: The Amazon Resource Name (ARN) of the resource scan.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: If the number of available results exceeds this maximum, the response
includes a NextToken value that you can use for the NextToken parameter to get the next set
of results. By default the ListResourceScanResources API action will return at most 100
results in each response. The maximum value is 100.
- `"NextToken"`: A string that identifies the next page of resource scan results.
- `"ResourceIdentifier"`: If specified, the returned resources will have the specified
resource identifier (or one of them in the case where the resource has multiple
identifiers).
- `"ResourceTypePrefix"`: If specified, the returned resources will be of any of the
resource types with the specified prefix.
- `"TagKey"`: If specified, the returned resources will have a matching tag key.
- `"TagValue"`: If specified, the returned resources will have a matching tag value.
"""
function list_resource_scan_resources(
ResourceScanId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListResourceScanResources",
Dict{String,Any}("ResourceScanId" => ResourceScanId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_resource_scan_resources(
ResourceScanId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListResourceScanResources",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceScanId" => ResourceScanId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_resource_scans()
list_resource_scans(params::Dict{String,<:Any})
List the resource scans from newest to oldest. By default it will return up to 10 resource
scans.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: If the number of available results exceeds this maximum, the response
includes a NextToken value that you can use for the NextToken parameter to get the next set
of results. The default value is 10. The maximum value is 100.
- `"NextToken"`: A string that identifies the next page of resource scan results.
"""
function list_resource_scans(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListResourceScans"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_resource_scans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListResourceScans", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_stack_instance_resource_drifts(operation_id, stack_instance_account, stack_instance_region, stack_set_name)
list_stack_instance_resource_drifts(operation_id, stack_instance_account, stack_instance_region, stack_set_name, params::Dict{String,<:Any})
Returns drift information for resources in a stack instance.
ListStackInstanceResourceDrifts returns drift information for the most recent drift
detection operation. If an operation is in progress, it may only return partial results.
# Arguments
- `operation_id`: The unique ID of the drift operation.
- `stack_instance_account`: The name of the Amazon Web Services account that you want to
list resource drifts for.
- `stack_instance_region`: The name of the Region where you want to list resource drifts.
- `stack_set_name`: The name or unique ID of the stack set that you want to list drifted
resources for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all of the remaining
results, the response object's NextToken parameter value is set to a token. To retrieve the
next set of results, call this action again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"StackInstanceResourceDriftStatuses"`: The resource drift status of the stack instance.
DELETED: The resource differs from its expected template configuration in that the
resource has been deleted. MODIFIED: One or more resource properties differ from their
expected template values. IN_SYNC: The resource's actual configuration matches its
expected template configuration. NOT_CHECKED: CloudFormation doesn't currently return
this value.
"""
function list_stack_instance_resource_drifts(
OperationId,
StackInstanceAccount,
StackInstanceRegion,
StackSetName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackInstanceResourceDrifts",
Dict{String,Any}(
"OperationId" => OperationId,
"StackInstanceAccount" => StackInstanceAccount,
"StackInstanceRegion" => StackInstanceRegion,
"StackSetName" => StackSetName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_instance_resource_drifts(
OperationId,
StackInstanceAccount,
StackInstanceRegion,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackInstanceResourceDrifts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"OperationId" => OperationId,
"StackInstanceAccount" => StackInstanceAccount,
"StackInstanceRegion" => StackInstanceRegion,
"StackSetName" => StackSetName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_instances(stack_set_name)
list_stack_instances(stack_set_name, params::Dict{String,<:Any})
Returns summary information about stack instances that are associated with the specified
stack set. You can filter for stack instances that are associated with a specific Amazon
Web Services account name or Region, or that have a specific status.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set that you want to list stack
instances for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"Filters"`: The filter to apply to stack instances
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous request didn't return all the remaining results, the
response's NextToken parameter value is set to a token. To retrieve the next set of
results, call ListStackInstances again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"StackInstanceAccount"`: The name of the Amazon Web Services account that you want to
list stack instances for.
- `"StackInstanceRegion"`: The name of the Region where you want to list stack instances.
"""
function list_stack_instances(
StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStackInstances",
Dict{String,Any}("StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_instances(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackInstances",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackSetName" => StackSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_resources(stack_name)
list_stack_resources(stack_name, params::Dict{String,<:Any})
Returns descriptions of all resources of the specified stack. For deleted stacks,
ListStackResources returns resource information for up to 90 days after the stack has been
deleted.
# Arguments
- `stack_name`: The name or the unique stack ID that is associated with the stack, which
aren't always interchangeable: Running stacks: You can specify either the stack's name or
its unique stack ID. Deleted stacks: You must specify the unique stack ID. Default:
There is no default value.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string that identifies the next page of stack resources that you want to
retrieve.
"""
function list_stack_resources(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListStackResources",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_resources(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackResources",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_set_auto_deployment_targets(stack_set_name)
list_stack_set_auto_deployment_targets(stack_set_name, params::Dict{String,<:Any})
Returns summary information about deployment targets for a stack set.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set that you want to get automatic
deployment targets for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: Specifies whether you are acting as an account administrator in the
organization's management account or as a delegated administrator in a member account. By
default, SELF is specified. Use SELF for StackSets with self-managed permissions. If you
are signed in to the management account, specify SELF. If you are signed in to a
delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web Services account
must be registered as a delegated administrator in the management account. For more
information, see Register a delegated administrator in the CloudFormation User Guide.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: A string that identifies the next page of stack set deployment targets
that you want to retrieve.
"""
function list_stack_set_auto_deployment_targets(
StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStackSetAutoDeploymentTargets",
Dict{String,Any}("StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_set_auto_deployment_targets(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackSetAutoDeploymentTargets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackSetName" => StackSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_set_operation_results(operation_id, stack_set_name)
list_stack_set_operation_results(operation_id, stack_set_name, params::Dict{String,<:Any})
Returns summary information about the results of a stack set operation.
# Arguments
- `operation_id`: The ID of the stack set operation.
- `stack_set_name`: The name or unique ID of the stack set that you want to get operation
results for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"Filters"`: The filter to apply to operation results.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous request didn't return all the remaining results, the
response object's NextToken parameter value is set to a token. To retrieve the next set of
results, call ListStackSetOperationResults again and assign that token to the request
object's NextToken parameter. If there are no remaining results, the previous response
object's NextToken parameter is set to null.
"""
function list_stack_set_operation_results(
OperationId, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStackSetOperationResults",
Dict{String,Any}("OperationId" => OperationId, "StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_set_operation_results(
OperationId,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackSetOperationResults",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"OperationId" => OperationId, "StackSetName" => StackSetName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_set_operations(stack_set_name)
list_stack_set_operations(stack_set_name, params::Dict{String,<:Any})
Returns summary information about operations performed on a stack set.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set that you want to get operation
summaries for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all of the remaining
results, the response object's NextToken parameter value is set to a token. To retrieve the
next set of results, call ListStackSetOperations again and assign that token to the request
object's NextToken parameter. If there are no remaining results, the previous response
object's NextToken parameter is set to null.
"""
function list_stack_set_operations(
StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStackSetOperations",
Dict{String,Any}("StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_stack_set_operations(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"ListStackSetOperations",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackSetName" => StackSetName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_stack_sets()
list_stack_sets(params::Dict{String,<:Any})
Returns summary information about stack sets that are associated with the user.
[Self-managed permissions] If you set the CallAs parameter to SELF while signed in to your
Amazon Web Services account, ListStackSets returns all self-managed stack sets in your
Amazon Web Services account. [Service-managed permissions] If you set the CallAs
parameter to SELF while signed in to the organization's management account, ListStackSets
returns all stack sets in the management account. [Service-managed permissions] If you
set the CallAs parameter to DELEGATED_ADMIN while signed in to your member account,
ListStackSets returns all stack sets with service-managed permissions in the management
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the management account or as a delegated administrator in a member
account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all the remaining results,
the response object's NextToken parameter value is set to a token. To retrieve the next set
of results, call ListStackSets again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"Status"`: The status of the stack sets that you want to get summary information about.
"""
function list_stack_sets(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListStackSets"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_stack_sets(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStackSets", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_stacks()
list_stacks(params::Dict{String,<:Any})
Returns the summary information for stacks whose status matches the specified
StackStatusFilter. Summary information for stacks that have been deleted is kept for 90
days after the stack is deleted. If no StackStatusFilter is specified, summary information
for all stacks is returned (including existing stacks and stacks that have been deleted).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: A string that identifies the next page of stacks that you want to retrieve.
- `"StackStatusFilter"`: Stack status to use as a filter. Specify one or more stack status
codes to list only stacks with the specified status codes. For a complete list of stack
status codes, see the StackStatus parameter of the Stack data type.
"""
function list_stacks(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListStacks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_stacks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListStacks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_type_registrations()
list_type_registrations(params::Dict{String,<:Any})
Returns a list of registration tokens for the specified extension(s).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all the remaining results,
the response object's NextToken parameter value is set to a token. To retrieve the next set
of results, call this action again and assign that token to the request object's NextToken
parameter. If there are no remaining results, the previous response object's NextToken
parameter is set to null.
- `"RegistrationStatusFilter"`: The current status of the extension registration request.
The default is IN_PROGRESS.
- `"Type"`: The kind of extension. Conditional: You must specify either TypeName and Type,
or Arn.
- `"TypeArn"`: The Amazon Resource Name (ARN) of the extension. Conditional: You must
specify either TypeName and Type, or Arn.
- `"TypeName"`: The name of the extension. Conditional: You must specify either TypeName
and Type, or Arn.
"""
function list_type_registrations(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListTypeRegistrations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_type_registrations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListTypeRegistrations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_type_versions()
list_type_versions(params::Dict{String,<:Any})
Returns summary information about the versions of an extension.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension for which you want version
summary information. Conditional: You must specify either TypeName and Type, or Arn.
- `"DeprecatedStatus"`: The deprecation status of the extension versions that you want to
get summary information about. Valid values include: LIVE: The extension version is
registered and can be used in CloudFormation operations, dependent on its provisioning
behavior and visibility scope. DEPRECATED: The extension version has been deregistered
and can no longer be used in CloudFormation operations. The default is LIVE.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all of the remaining
results, the response object's NextToken parameter value is set to a token. To retrieve the
next set of results, call this action again and assign that token to the request object's
NextToken parameter. If there are no remaining results, the previous response object's
NextToken parameter is set to null.
- `"PublisherId"`: The publisher ID of the extension publisher. Extensions published by
Amazon aren't assigned a publisher ID.
- `"Type"`: The kind of the extension. Conditional: You must specify either TypeName and
Type, or Arn.
- `"TypeName"`: The name of the extension for which you want version summary information.
Conditional: You must specify either TypeName and Type, or Arn.
"""
function list_type_versions(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListTypeVersions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_type_versions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListTypeVersions", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_types()
list_types(params::Dict{String,<:Any})
Returns summary information about extension that have been registered with CloudFormation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DeprecatedStatus"`: The deprecation status of the extension that you want to get
summary information about. Valid values include: LIVE: The extension is registered for
use in CloudFormation operations. DEPRECATED: The extension has been deregistered and
can no longer be used in CloudFormation operations.
- `"Filters"`: Filter criteria to use in determining which extensions to return. Filters
must be compatible with Visibility to return valid results. For example, specifying
AWS_TYPES for Category and PRIVATE for Visibility returns an empty list of types, but
specifying PUBLIC for Visibility returns the desired list.
- `"MaxResults"`: The maximum number of results to be returned with a single call. If the
number of available results exceeds this maximum, the response includes a NextToken value
that you can assign to the NextToken request parameter to get the next set of results.
- `"NextToken"`: If the previous paginated request didn't return all the remaining results,
the response object's NextToken parameter value is set to a token. To retrieve the next set
of results, call this action again and assign that token to the request object's NextToken
parameter. If there are no remaining results, the previous response object's NextToken
parameter is set to null.
- `"ProvisioningType"`: For resource types, the provisioning behavior of the resource type.
CloudFormation determines the provisioning type during registration, based on the types of
handlers in the schema handler package submitted. Valid values include: FULLY_MUTABLE:
The resource type includes an update handler to process updates to the type during stack
update operations. IMMUTABLE: The resource type doesn't include an update handler, so
the type can't be updated and must instead be replaced during stack update operations.
NON_PROVISIONABLE: The resource type doesn't include create, read, and delete handlers, and
therefore can't actually be provisioned. The default is FULLY_MUTABLE.
- `"Type"`: The type of extension.
- `"Visibility"`: The scope at which the extensions are visible and usable in
CloudFormation operations. Valid values include: PRIVATE: Extensions that are visible
and usable within this account and Region. This includes: Private extensions you have
registered in this account and Region. Public extensions that you have activated in this
account and Region. PUBLIC: Extensions that are publicly visible and available to be
activated within any Amazon Web Services account. This includes extensions from Amazon Web
Services, in addition to third-party publishers. The default is PRIVATE.
"""
function list_types(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ListTypes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ListTypes", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
publish_type()
publish_type(params::Dict{String,<:Any})
Publishes the specified extension to the CloudFormation registry as a public extension in
this Region. Public extensions are available for use by all CloudFormation users. For more
information about publishing extensions, see Publishing extensions to make them available
for public use in the CloudFormation CLI User Guide. To publish an extension, you must be
registered as a publisher with CloudFormation. For more information, see RegisterPublisher.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension. Conditional: You must specify
Arn, or TypeName and Type.
- `"PublicVersionNumber"`: The version number to assign to this version of the extension.
Use the following format, and adhere to semantic versioning when assigning a version number
to your extension: MAJOR.MINOR.PATCH For more information, see Semantic Versioning 2.0.0.
If you don't specify a version number, CloudFormation increments the version number by one
minor version release. You cannot specify a version number the first time you publish a
type. CloudFormation automatically sets the first version number to be 1.0.0.
- `"Type"`: The type of the extension. Conditional: You must specify Arn, or TypeName and
Type.
- `"TypeName"`: The name of the extension. Conditional: You must specify Arn, or TypeName
and Type.
"""
function publish_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"PublishType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function publish_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"PublishType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
record_handler_progress(bearer_token, operation_status)
record_handler_progress(bearer_token, operation_status, params::Dict{String,<:Any})
Reports progress of a resource handler to CloudFormation. Reserved for use by the
CloudFormation CLI. Don't use this API in your code.
# Arguments
- `bearer_token`: Reserved for use by the CloudFormation CLI.
- `operation_status`: Reserved for use by the CloudFormation CLI.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: Reserved for use by the CloudFormation CLI.
- `"CurrentOperationStatus"`: Reserved for use by the CloudFormation CLI.
- `"ErrorCode"`: Reserved for use by the CloudFormation CLI.
- `"ResourceModel"`: Reserved for use by the CloudFormation CLI.
- `"StatusMessage"`: Reserved for use by the CloudFormation CLI.
"""
function record_handler_progress(
BearerToken, OperationStatus; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"RecordHandlerProgress",
Dict{String,Any}(
"BearerToken" => BearerToken, "OperationStatus" => OperationStatus
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function record_handler_progress(
BearerToken,
OperationStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"RecordHandlerProgress",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BearerToken" => BearerToken, "OperationStatus" => OperationStatus
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_publisher()
register_publisher(params::Dict{String,<:Any})
Registers your account as a publisher of public extensions in the CloudFormation registry.
Public extensions are available for use by all CloudFormation users. This publisher ID
applies to your account in all Amazon Web Services Regions. For information about
requirements for registering as a public extension publisher, see Registering your account
to publish CloudFormation extensions in the CloudFormation CLI User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AcceptTermsAndConditions"`: Whether you accept the Terms and Conditions for publishing
extensions in the CloudFormation registry. You must accept the terms and conditions in
order to register to publish public extensions to the CloudFormation registry. The default
is false.
- `"ConnectionArn"`: If you are using a Bitbucket or GitHub account for identity
verification, the Amazon Resource Name (ARN) for your connection to that account. For more
information, see Registering your account to publish CloudFormation extensions in the
CloudFormation CLI User Guide.
"""
function register_publisher(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"RegisterPublisher"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function register_publisher(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"RegisterPublisher", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
register_type(schema_handler_package, type_name)
register_type(schema_handler_package, type_name, params::Dict{String,<:Any})
Registers an extension with the CloudFormation service. Registering an extension makes it
available for use in CloudFormation templates in your Amazon Web Services account, and
includes: Validating the extension schema. Determining which handlers, if any, have
been specified for the extension. Making the extension available for use in your account.
For more information about how to develop extensions and ready them for registration, see
Creating Resource Providers in the CloudFormation CLI User Guide. You can have a maximum of
50 resource extension versions registered at a time. This maximum is per account and per
Region. Use DeregisterType to deregister specific extension versions if necessary. Once you
have initiated a registration request using RegisterType, you can use
DescribeTypeRegistration to monitor the progress of the registration request. Once you have
registered a private extension in your account and Region, use SetTypeConfiguration to
specify configuration properties for the extension. For more information, see Configuring
extensions at the account level in the CloudFormation User Guide.
# Arguments
- `schema_handler_package`: A URL to the S3 bucket containing the extension project package
that contains the necessary files for the extension you want to register. For information
about generating a schema handler package for the extension you want to register, see
submit in the CloudFormation CLI User Guide. The user registering the extension must be
able to access the package in the S3 bucket. That's, the user needs to have GetObject
permissions for the schema handler package. For more information, see Actions, Resources,
and Condition Keys for Amazon S3 in the Identity and Access Management User Guide.
- `type_name`: The name of the extension being registered. We suggest that extension names
adhere to the following patterns: For resource types,
company_or_organization::service::type. For modules,
company_or_organization::service::type::MODULE. For hooks,
MyCompany::Testing::MyTestHook. The following organization namespaces are reserved and
can't be used in your extension names: Alexa AMZN Amazon AWS Custom
Dev
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier that acts as an idempotency key for this
registration request. Specifying a client request token prevents CloudFormation from
generating more than one version of an extension from the same registration request, even
if the request is submitted multiple times.
- `"ExecutionRoleArn"`: The Amazon Resource Name (ARN) of the IAM role for CloudFormation
to assume when invoking the extension. For CloudFormation to assume the specified execution
role, the role must contain a trust relationship with the CloudFormation service principal
(resources.cloudformation.amazonaws.com). For more information about adding trust
relationships, see Modifying a role trust policy in the Identity and Access Management User
Guide. If your extension calls Amazon Web Services APIs in any of its handlers, you must
create an IAM execution role that includes the necessary permissions to call those Amazon
Web Services APIs, and provision that execution role in your account. When CloudFormation
needs to invoke the resource type handler, CloudFormation assumes this execution role to
create a temporary session token, which it then passes to the resource type handler,
thereby supplying your resource type with the appropriate credentials.
- `"LoggingConfig"`: Specifies logging configuration information for an extension.
- `"Type"`: The kind of extension.
"""
function register_type(
SchemaHandlerPackage, TypeName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"RegisterType",
Dict{String,Any}(
"SchemaHandlerPackage" => SchemaHandlerPackage, "TypeName" => TypeName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_type(
SchemaHandlerPackage,
TypeName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"RegisterType",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"SchemaHandlerPackage" => SchemaHandlerPackage, "TypeName" => TypeName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
rollback_stack(stack_name)
rollback_stack(stack_name, params::Dict{String,<:Any})
When specifying RollbackStack, you preserve the state of previously provisioned resources
when an operation fails. You can check the status of the stack through the DescribeStacks
operation. Rolls back the specified stack to the last known stable state from CREATE_FAILED
or UPDATE_FAILED stack statuses. This operation will delete a stack if it doesn't contain a
last known stable state. A last known stable state includes any status in a *_COMPLETE.
This includes the following stack statuses. CREATE_COMPLETE UPDATE_COMPLETE
UPDATE_ROLLBACK_COMPLETE IMPORT_COMPLETE IMPORT_ROLLBACK_COMPLETE
# Arguments
- `stack_name`: The name that's associated with the stack.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this RollbackStack request.
- `"RetainExceptOnCreate"`: When set to true, newly created resources are deleted when the
operation rolls back. This includes newly created resources marked with a deletion policy
of Retain. Default: false
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management role
that CloudFormation assumes to rollback the stack.
"""
function rollback_stack(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"RollbackStack",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function rollback_stack(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"RollbackStack",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_stack_policy(stack_name)
set_stack_policy(stack_name, params::Dict{String,<:Any})
Sets a stack policy for a specified stack.
# Arguments
- `stack_name`: The name or unique stack ID that you want to associate a policy with.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StackPolicyBody"`: Structure containing the stack policy body. For more information, go
to Prevent updates to stack resources in the CloudFormation User Guide. You can specify
either the StackPolicyBody or the StackPolicyURL parameter, but not both.
- `"StackPolicyURL"`: Location of a file containing the stack policy. The URL must point to
a policy (maximum size: 16 KB) located in an Amazon S3 bucket in the same Amazon Web
Services Region as the stack. The location for an Amazon S3 bucket must start with
https://. You can specify either the StackPolicyBody or the StackPolicyURL parameter, but
not both.
"""
function set_stack_policy(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"SetStackPolicy",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_stack_policy(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"SetStackPolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_type_configuration(configuration)
set_type_configuration(configuration, params::Dict{String,<:Any})
Specifies the configuration data for a registered CloudFormation extension, in the given
account and Region. To view the current configuration data for an extension, refer to the
ConfigurationSchema element of DescribeType. For more information, see Configuring
extensions at the account level in the CloudFormation User Guide. It's strongly
recommended that you use dynamic references to restrict sensitive configuration
definitions, such as third-party credentials. For more details on dynamic references, see
Using dynamic references to specify template values in the CloudFormation User Guide.
# Arguments
- `configuration`: The configuration data for the extension, in this account and Region.
The configuration data must be formatted as JSON, and validate against the schema returned
in the ConfigurationSchema response element of DescribeType. For more information, see
Defining account-level configuration data for an extension in the CloudFormation CLI User
Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConfigurationAlias"`: An alias by which to refer to this extension configuration data.
Conditional: Specifying a configuration alias is required when setting a configuration for
a resource type extension.
- `"Type"`: The type of extension. Conditional: You must specify ConfigurationArn, or Type
and TypeName.
- `"TypeArn"`: The Amazon Resource Name (ARN) for the extension, in this account and
Region. For public extensions, this will be the ARN assigned when you call the ActivateType
API operation in this account and Region. For private extensions, this will be the ARN
assigned when you call the RegisterType API operation in this account and Region. Do not
include the extension versions suffix at the end of the ARN. You can set the configuration
for an extension, but not for a specific extension version.
- `"TypeName"`: The name of the extension. Conditional: You must specify ConfigurationArn,
or Type and TypeName.
"""
function set_type_configuration(
Configuration; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"SetTypeConfiguration",
Dict{String,Any}("Configuration" => Configuration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_type_configuration(
Configuration,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"SetTypeConfiguration",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Configuration" => Configuration), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_type_default_version()
set_type_default_version(params::Dict{String,<:Any})
Specify the default version of an extension. The default version of an extension will be
used in CloudFormation operations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension for which you want version
summary information. Conditional: You must specify either TypeName and Type, or Arn.
- `"Type"`: The kind of extension. Conditional: You must specify either TypeName and Type,
or Arn.
- `"TypeName"`: The name of the extension. Conditional: You must specify either TypeName
and Type, or Arn.
- `"VersionId"`: The ID of a specific version of the extension. The version ID is the value
at the end of the Amazon Resource Name (ARN) assigned to the extension version when it is
registered.
"""
function set_type_default_version(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"SetTypeDefaultVersion"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function set_type_default_version(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"SetTypeDefaultVersion",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
signal_resource(logical_resource_id, stack_name, status, unique_id)
signal_resource(logical_resource_id, stack_name, status, unique_id, params::Dict{String,<:Any})
Sends a signal to the specified resource with a success or failure status. You can use the
SignalResource operation in conjunction with a creation policy or update policy.
CloudFormation doesn't proceed with a stack creation or update until resources receive the
required number of signals or the timeout period is exceeded. The SignalResource operation
is useful in cases where you want to send signals from anywhere other than an Amazon EC2
instance.
# Arguments
- `logical_resource_id`: The logical ID of the resource that you want to signal. The
logical ID is the name of the resource that given in the template.
- `stack_name`: The stack name or unique stack ID that includes the resource that you want
to signal.
- `status`: The status of the signal, which is either success or failure. A failure signal
causes CloudFormation to immediately fail the stack creation or update.
- `unique_id`: A unique ID of the signal. When you signal Amazon EC2 instances or Auto
Scaling groups, specify the instance ID that you are signaling as the unique ID. If you
send multiple signals to a single resource (such as signaling a wait condition), each
signal requires a different unique ID.
"""
function signal_resource(
LogicalResourceId,
StackName,
Status,
UniqueId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"SignalResource",
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId,
"StackName" => StackName,
"Status" => Status,
"UniqueId" => UniqueId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function signal_resource(
LogicalResourceId,
StackName,
Status,
UniqueId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"SignalResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"LogicalResourceId" => LogicalResourceId,
"StackName" => StackName,
"Status" => Status,
"UniqueId" => UniqueId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_resource_scan()
start_resource_scan(params::Dict{String,<:Any})
Starts a scan of the resources in this account in this Region. You can the status of a scan
using the ListResourceScans API action.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: A unique identifier for this StartResourceScan request. Specify
this token if you plan to retry requests so that CloudFormation knows that you're not
attempting to start a new resource scan.
"""
function start_resource_scan(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"StartResourceScan"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function start_resource_scan(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"StartResourceScan", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
stop_stack_set_operation(operation_id, stack_set_name)
stop_stack_set_operation(operation_id, stack_set_name, params::Dict{String,<:Any})
Stops an in-progress operation on a stack set and its associated stack instances. StackSets
will cancel all the unstarted stack instance deployments and wait for those are in-progress
to complete.
# Arguments
- `operation_id`: The ID of the stack operation.
- `stack_set_name`: The name or unique ID of the stack set that you want to stop the
operation for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
"""
function stop_stack_set_operation(
OperationId, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"StopStackSetOperation",
Dict{String,Any}("OperationId" => OperationId, "StackSetName" => StackSetName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_stack_set_operation(
OperationId,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"StopStackSetOperation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"OperationId" => OperationId, "StackSetName" => StackSetName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_type()
test_type(params::Dict{String,<:Any})
Tests a registered extension to make sure it meets all necessary requirements for being
published in the CloudFormation registry. For resource types, this includes passing all
contracts tests defined for the type. For modules, this includes determining if the
module's model meets all necessary requirements. For more information, see Testing your
public extension prior to publishing in the CloudFormation CLI User Guide. If you don't
specify a version, CloudFormation uses the default version of the extension in your account
and Region for testing. To perform testing, CloudFormation assumes the execution role
specified when the type was registered. For more information, see RegisterType. Once you've
initiated testing on an extension using TestType, you can pass the returned TypeVersionArn
into DescribeType to monitor the current test status and test status description for the
extension. An extension must have a test status of PASSED before it can be published. For
more information, see Publishing extensions to make them available for public use in the
CloudFormation CLI User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Arn"`: The Amazon Resource Name (ARN) of the extension. Conditional: You must specify
Arn, or TypeName and Type.
- `"LogDeliveryBucket"`: The S3 bucket to which CloudFormation delivers the contract test
execution logs. CloudFormation delivers the logs by the time contract testing has completed
and the extension has been assigned a test type status of PASSED or FAILED. The user
calling TestType must be able to access items in the specified S3 bucket. Specifically, the
user needs the following permissions: GetObject PutObject For more information,
see Actions, Resources, and Condition Keys for Amazon S3 in the Amazon Web Services
Identity and Access Management User Guide.
- `"Type"`: The type of the extension to test. Conditional: You must specify Arn, or
TypeName and Type.
- `"TypeName"`: The name of the extension to test. Conditional: You must specify Arn, or
TypeName and Type.
- `"VersionId"`: The version of the extension to test. You can specify the version id with
either Arn, or with TypeName and Type. If you don't specify a version, CloudFormation uses
the default version of the extension in this account and Region for testing.
"""
function test_type(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"TestType"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function test_type(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"TestType", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_generated_template(generated_template_name)
update_generated_template(generated_template_name, params::Dict{String,<:Any})
Updates a generated template. This can be used to change the name, add and remove
resources, refresh resources, and change the DeletionPolicy and UpdateReplacePolicy
settings. You can check the status of the update to the generated template using the
DescribeGeneratedTemplate API action.
# Arguments
- `generated_template_name`: The name or Amazon Resource Name (ARN) of a generated template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AddResources"`: An optional list of resources to be added to the generated template.
- `"NewGeneratedTemplateName"`: An optional new name to assign to the generated template.
- `"RefreshAllResources"`: If true, update the resource properties in the generated
template with their current live state. This feature is useful when the resource properties
in your generated a template does not reflect the live state of the resource properties.
This happens when a user update the resource properties after generating a template.
- `"RemoveResources"`: A list of logical ids for resources to remove from the generated
template.
- `"TemplateConfiguration"`: The configuration details of the generated template, including
the DeletionPolicy and UpdateReplacePolicy.
"""
function update_generated_template(
GeneratedTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"UpdateGeneratedTemplate",
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_generated_template(
GeneratedTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateGeneratedTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("GeneratedTemplateName" => GeneratedTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stack(stack_name)
update_stack(stack_name, params::Dict{String,<:Any})
Updates a stack as specified in the template. After the call completes successfully, the
stack update starts. You can check the status of the stack through the DescribeStacks
action. To get a copy of the template for an existing stack, you can use the GetTemplate
action. For more information about creating an update template, updating a stack, and
monitoring the progress of the update, see Updating a Stack.
# Arguments
- `stack_name`: The name or unique stack ID of the stack to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Capabilities"`: In some cases, you must explicitly acknowledge that your stack template
contains certain capabilities in order for CloudFormation to update the stack.
CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack templates might include resources that
can affect permissions in your Amazon Web Services account; for example, by creating new
Identity and Access Management (IAM) users. For those stacks, you must explicitly
acknowledge this by specifying one of these capabilities. The following IAM resources
require you to specify either the CAPABILITY_IAM or CAPABILITY_NAMED_IAM capability. If
you have IAM resources, you can specify either capability. If you have IAM resources with
custom names, you must specify CAPABILITY_NAMED_IAM. If you don't specify either of these
capabilities, CloudFormation returns an InsufficientCapabilities error. If your stack
template contains these resources, we suggest that you review all permissions associated
with them and edit their permissions if necessary. AWS::IAM::AccessKey
AWS::IAM::Group AWS::IAM::InstanceProfile AWS::IAM::Policy AWS::IAM::Role
AWS::IAM::User AWS::IAM::UserToGroupAddition For more information, see Acknowledging
IAM Resources in CloudFormation Templates. CAPABILITY_AUTO_EXPAND Some template contain
macros. Macros perform custom processing on templates; this can include simple actions like
find-and-replace operations, all the way to extensive transformations of entire templates.
Because of this, users typically create a change set from the processed template, so that
they can review the changes resulting from the macros before actually updating the stack.
If your stack template contains one or more macros, and you choose to update a stack
directly from the processed template, without first reviewing the resulting changes in a
change set, you must acknowledge this capability. This includes the AWS::Include and
AWS::Serverless transforms, which are macros hosted by CloudFormation. If you want to
update a stack from a stack template that contains macros and nested stacks, you must
update the stack directly from the template using this capability. You should only update
stacks directly from a stack template that contains macros if you know what processing the
macro performs. Each macro relies on an underlying Lambda service function for processing
stack templates. Be aware that the Lambda function owner can update the function operation
without CloudFormation being notified. For more information, see Using CloudFormation
Macros to Perform Custom Processing on Templates. Only one of the Capabilities and
ResourceType parameters can be specified.
- `"ClientRequestToken"`: A unique identifier for this UpdateStack request. Specify this
token if you plan to retry requests so that CloudFormation knows that you're not attempting
to update a stack with the same name. You might retry UpdateStack requests to ensure that
CloudFormation successfully received them. All events triggered by a given stack operation
are assigned the same client request token, which you can use to track operations. For
example, if you execute a CreateStack operation with the token token1, then all the
StackEvents generated by that operation will have ClientRequestToken set as token1. In the
console, stack operations display the client request token on the Events tab. Stack
operations that are initiated from the console use the token format
Console-StackOperation-ID, which helps you easily identify the stack operation . For
example, if you create a stack using the console, each stack event would be assigned the
same token in the following format:
Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002.
- `"DisableRollback"`: Preserve the state of previously provisioned resources when an
operation fails. Default: False
- `"NotificationARNs"`: Amazon Simple Notification Service topic Amazon Resource Names
(ARNs) that CloudFormation associates with the stack. Specify an empty list to remove all
notification topics.
- `"Parameters"`: A list of Parameter structures that specify input parameters for the
stack. For more information, see the Parameter data type.
- `"ResourceTypes"`: The template resource types that you have permissions to work with for
this update stack action, such as AWS::EC2::Instance, AWS::EC2::*, or
Custom::MyCustomInstance. If the list of resource types doesn't include a resource that
you're updating, the stack update fails. By default, CloudFormation grants permissions to
all resource types. Identity and Access Management (IAM) uses this parameter for
CloudFormation-specific condition keys in IAM policies. For more information, see
Controlling Access with Identity and Access Management. Only one of the Capabilities and
ResourceType parameters can be specified.
- `"RetainExceptOnCreate"`: When set to true, newly created resources are deleted when the
operation rolls back. This includes newly created resources marked with a deletion policy
of Retain. Default: false
- `"RoleARN"`: The Amazon Resource Name (ARN) of an Identity and Access Management (IAM)
role that CloudFormation assumes to update the stack. CloudFormation uses the role's
credentials to make calls on your behalf. CloudFormation always uses this role for all
future operations on the stack. Provided that users have permission to operate on the
stack, CloudFormation uses this role even if the users don't have permission to pass it.
Ensure that the role grants least privilege. If you don't specify a value, CloudFormation
uses the role that was previously associated with the stack. If no role is available,
CloudFormation uses a temporary session that is generated from your user credentials.
- `"RollbackConfiguration"`: The rollback triggers for CloudFormation to monitor during
stack creation and updating operations, and for the specified monitoring period afterwards.
- `"StackPolicyBody"`: Structure containing a new stack policy body. You can specify either
the StackPolicyBody or the StackPolicyURL parameter, but not both. You might update the
stack policy, for example, in order to protect a new resource that you created during a
stack update. If you don't specify a stack policy, the current policy that is associated
with the stack is unchanged.
- `"StackPolicyDuringUpdateBody"`: Structure containing the temporary overriding stack
policy body. You can specify either the StackPolicyDuringUpdateBody or the
StackPolicyDuringUpdateURL parameter, but not both. If you want to update protected
resources, specify a temporary overriding stack policy during this update. If you don't
specify a stack policy, the current policy that is associated with the stack will be used.
- `"StackPolicyDuringUpdateURL"`: Location of a file containing the temporary overriding
stack policy. The URL must point to a policy (max size: 16KB) located in an S3 bucket in
the same Region as the stack. The location for an Amazon S3 bucket must start with
https://. You can specify either the StackPolicyDuringUpdateBody or the
StackPolicyDuringUpdateURL parameter, but not both. If you want to update protected
resources, specify a temporary overriding stack policy during this update. If you don't
specify a stack policy, the current policy that is associated with the stack will be used.
- `"StackPolicyURL"`: Location of a file containing the updated stack policy. The URL must
point to a policy (max size: 16KB) located in an S3 bucket in the same Region as the stack.
The location for an Amazon S3 bucket must start with https://. You can specify either the
StackPolicyBody or the StackPolicyURL parameter, but not both. You might update the stack
policy, for example, in order to protect a new resource that you created during a stack
update. If you don't specify a stack policy, the current policy that is associated with the
stack is unchanged.
- `"Tags"`: Key-value pairs to associate with this stack. CloudFormation also propagates
these tags to supported resources in the stack. You can specify a maximum number of 50
tags. If you don't specify this parameter, CloudFormation doesn't modify the stack's tags.
If you specify an empty value, CloudFormation removes all associated tags.
- `"TemplateBody"`: Structure containing the template body with a minimum length of 1 byte
and a maximum length of 51,200 bytes. (For more information, go to Template Anatomy in the
CloudFormation User Guide.) Conditional: You must specify only one of the following
parameters: TemplateBody, TemplateURL, or set the UsePreviousTemplate to true.
- `"TemplateURL"`: Location of file containing the template body. The URL must point to a
template that's located in an Amazon S3 bucket or a Systems Manager document. For more
information, go to Template Anatomy in the CloudFormation User Guide. The location for an
Amazon S3 bucket must start with https://. Conditional: You must specify only one of the
following parameters: TemplateBody, TemplateURL, or set the UsePreviousTemplate to true.
- `"UsePreviousTemplate"`: Reuse the existing template that is associated with the stack
that you are updating. Conditional: You must specify only one of the following parameters:
TemplateBody, TemplateURL, or set the UsePreviousTemplate to true.
"""
function update_stack(StackName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"UpdateStack",
Dict{String,Any}("StackName" => StackName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stack(
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateStack",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("StackName" => StackName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stack_instances(regions, stack_set_name)
update_stack_instances(regions, stack_set_name, params::Dict{String,<:Any})
Updates the parameter values for stack instances for the specified accounts, within the
specified Amazon Web Services Regions. A stack instance refers to a stack in a specific
account and Region. You can only update stack instances in Amazon Web Services Regions and
accounts where they already exist; to create additional stack instances, use
CreateStackInstances. During stack set updates, any parameters overridden for a stack
instance aren't updated, but retain their overridden value. You can only update the
parameter values that are specified in the stack set; to add or delete a parameter itself,
use UpdateStackSet to update the stack set template. If you add a parameter to a template,
before you can override the parameter value specified in the stack set you must first use
UpdateStackSet to update all stack instances with the updated template and parameter value
specified in the stack set. Once a stack instance has been updated with the new parameter,
you can then override the parameter value using UpdateStackInstances.
# Arguments
- `regions`: The names of one or more Amazon Web Services Regions in which you want to
update parameter values for stack instances. The overridden parameter values will be
applied to all stack instances in the specified accounts and Amazon Web Services Regions.
- `stack_set_name`: The name or unique ID of the stack set associated with the stack
instances.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accounts"`: [Self-managed permissions] The names of one or more Amazon Web Services
accounts for which you want to update parameter values for stack instances. The overridden
parameter values will be applied to all stack instances in the specified accounts and
Amazon Web Services Regions. You can specify Accounts or DeploymentTargets, but not both.
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"DeploymentTargets"`: [Service-managed permissions] The Organizations accounts for which
you want to update parameter values for stack instances. If your update targets OUs, the
overridden parameter values only apply to the accounts that are currently in the target OUs
and their child OUs. Accounts added to the target OUs and their child OUs in the future
won't use the overridden values. You can specify Accounts or DeploymentTargets, but not
both.
- `"OperationId"`: The unique identifier for this stack set operation. The operation ID
also functions as an idempotency token, to ensure that CloudFormation performs the stack
set operation only once, even if you retry the request multiple times. You might retry
stack set operation requests to ensure that CloudFormation successfully received them. If
you don't specify an operation ID, the SDK generates one automatically.
- `"OperationPreferences"`: Preferences for how CloudFormation performs this stack set
operation.
- `"ParameterOverrides"`: A list of input parameters whose values you want to update for
the specified stack instances. Any overridden parameter values will be applied to all stack
instances in the specified accounts and Amazon Web Services Regions. When specifying
parameters and their values, be aware of how CloudFormation sets parameter values during
stack instance update operations: To override the current value for a parameter, include
the parameter and specify its value. To leave an overridden parameter set to its present
value, include the parameter and specify UsePreviousValue as true. (You can't specify both
a value and set UsePreviousValue to true.) To set an overridden parameter back to the
value specified in the stack set, specify a parameter list but don't include the parameter
in the list. To leave all parameters set to their present values, don't specify this
property at all. During stack set updates, any parameter values overridden for a stack
instance aren't updated, but retain their overridden value. You can only override the
parameter values that are specified in the stack set; to add or delete a parameter itself,
use UpdateStackSet to update the stack set template. If you add a parameter to a template,
before you can override the parameter value specified in the stack set you must first use
UpdateStackSet to update all stack instances with the updated template and parameter value
specified in the stack set. Once a stack instance has been updated with the new parameter,
you can then override the parameter value using UpdateStackInstances.
"""
function update_stack_instances(
Regions, StackSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"UpdateStackInstances",
Dict{String,Any}(
"Regions" => Regions,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stack_instances(
Regions,
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateStackInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Regions" => Regions,
"StackSetName" => StackSetName,
"OperationId" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_stack_set(stack_set_name)
update_stack_set(stack_set_name, params::Dict{String,<:Any})
Updates the stack set, and associated stack instances in the specified accounts and Amazon
Web Services Regions. Even if the stack set operation created by updating the stack set
fails (completely or partially, below or above a specified failure tolerance), the stack
set is updated with your changes. Subsequent CreateStackInstances calls on the specified
stack set use the updated stack set.
# Arguments
- `stack_set_name`: The name or unique ID of the stack set that you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accounts"`: [Self-managed permissions] The accounts in which to update associated stack
instances. If you specify accounts, you must also specify the Amazon Web Services Regions
in which to update stack set instances. To update all the stack instances associated with
this stack set, don't specify the Accounts or Regions properties. If the stack set update
includes changes to the template (that is, if the TemplateBody or TemplateURL properties
are specified), or the Parameters property, CloudFormation marks all stack instances with a
status of OUTDATED prior to updating the stack instances in the specified accounts and
Amazon Web Services Regions. If the stack set update does not include changes to the
template or parameters, CloudFormation updates the stack instances in the specified
accounts and Amazon Web Services Regions, while leaving all other stack instances with
their existing stack instance status.
- `"AdministrationRoleARN"`: The Amazon Resource Name (ARN) of the IAM role to use to
update this stack set. Specify an IAM role only if you are using customized administrator
roles to control which users or groups can manage specific stack sets within the same
administrator account. For more information, see Granting Permissions for Stack Set
Operations in the CloudFormation User Guide. If you specified a customized administrator
role when you created the stack set, you must specify a customized administrator role, even
if it is the same customized administrator role used with this stack set previously.
- `"AutoDeployment"`: [Service-managed permissions] Describes whether StackSets
automatically deploys to Organizations accounts that are added to a target organization or
organizational unit (OU). If you specify AutoDeployment, don't specify DeploymentTargets or
Regions.
- `"CallAs"`: [Service-managed permissions] Specifies whether you are acting as an account
administrator in the organization's management account or as a delegated administrator in a
member account. By default, SELF is specified. Use SELF for stack sets with self-managed
permissions. If you are signed in to the management account, specify SELF. If you are
signed in to a delegated administrator account, specify DELEGATED_ADMIN. Your Amazon Web
Services account must be registered as a delegated administrator in the management account.
For more information, see Register a delegated administrator in the CloudFormation User
Guide.
- `"Capabilities"`: In some cases, you must explicitly acknowledge that your stack template
contains certain capabilities in order for CloudFormation to update the stack set and its
associated stack instances. CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack
templates might include resources that can affect permissions in your Amazon Web Services
account; for example, by creating new Identity and Access Management (IAM) users. For those
stacks sets, you must explicitly acknowledge this by specifying one of these capabilities.
The following IAM resources require you to specify either the CAPABILITY_IAM or
CAPABILITY_NAMED_IAM capability. If you have IAM resources, you can specify either
capability. If you have IAM resources with custom names, you must specify
CAPABILITY_NAMED_IAM. If you don't specify either of these capabilities, CloudFormation
returns an InsufficientCapabilities error. If your stack template contains these
resources, we recommend that you review all permissions associated with them and edit their
permissions if necessary. AWS::IAM::AccessKey AWS::IAM::Group
AWS::IAM::InstanceProfile AWS::IAM::Policy AWS::IAM::Role AWS::IAM::User
AWS::IAM::UserToGroupAddition For more information, see Acknowledging IAM Resources in
CloudFormation Templates. CAPABILITY_AUTO_EXPAND Some templates reference macros. If
your stack set template references one or more macros, you must update the stack set
directly from the processed template, without first reviewing the resulting changes in a
change set. To update the stack set directly, you must acknowledge this capability. For
more information, see Using CloudFormation Macros to Perform Custom Processing on
Templates. Stack sets with service-managed permissions do not currently support the use of
macros in templates. (This includes the AWS::Include and AWS::Serverless transforms, which
are macros hosted by CloudFormation.) Even if you specify this capability for a stack set
with service-managed permissions, if you reference a macro in your template the stack set
operation will fail.
- `"DeploymentTargets"`: [Service-managed permissions] The Organizations accounts in which
to update associated stack instances. To update all the stack instances associated with
this stack set, do not specify DeploymentTargets or Regions. If the stack set update
includes changes to the template (that is, if TemplateBody or TemplateURL is specified), or
the Parameters, CloudFormation marks all stack instances with a status of OUTDATED prior to
updating the stack instances in the specified accounts and Amazon Web Services Regions. If
the stack set update doesn't include changes to the template or parameters, CloudFormation
updates the stack instances in the specified accounts and Regions, while leaving all other
stack instances with their existing stack instance status.
- `"Description"`: A brief description of updates that you are making.
- `"ExecutionRoleName"`: The name of the IAM execution role to use to update the stack set.
If you do not specify an execution role, CloudFormation uses the
AWSCloudFormationStackSetExecutionRole role for the stack set operation. Specify an IAM
role only if you are using customized execution roles to control which stack resources
users and groups can include in their stack sets. If you specify a customized execution
role, CloudFormation uses that role to update the stack. If you do not specify a customized
execution role, CloudFormation performs the update using the role previously associated
with the stack set, so long as you have permissions to perform operations on the stack set.
- `"ManagedExecution"`: Describes whether StackSets performs non-conflicting operations
concurrently and queues conflicting operations.
- `"OperationId"`: The unique ID for this stack set operation. The operation ID also
functions as an idempotency token, to ensure that CloudFormation performs the stack set
operation only once, even if you retry the request multiple times. You might retry stack
set operation requests to ensure that CloudFormation successfully received them. If you
don't specify an operation ID, CloudFormation generates one automatically. Repeating this
stack set operation with a new operation ID retries all stack instances whose status is
OUTDATED.
- `"OperationPreferences"`: Preferences for how CloudFormation performs this stack set
operation.
- `"Parameters"`: A list of input parameters for the stack set template.
- `"PermissionModel"`: Describes how the IAM roles required for stack set operations are
created. You cannot modify PermissionModel if there are stack instances associated with
your stack set. With self-managed permissions, you must create the administrator and
execution roles required to deploy to target accounts. For more information, see Grant
Self-Managed Stack Set Permissions. With service-managed permissions, StackSets
automatically creates the IAM roles required to deploy to accounts managed by
Organizations. For more information, see Grant Service-Managed Stack Set Permissions.
- `"Regions"`: The Amazon Web Services Regions in which to update associated stack
instances. If you specify Regions, you must also specify accounts in which to update stack
set instances. To update all the stack instances associated with this stack set, do not
specify the Accounts or Regions properties. If the stack set update includes changes to the
template (that is, if the TemplateBody or TemplateURL properties are specified), or the
Parameters property, CloudFormation marks all stack instances with a status of OUTDATED
prior to updating the stack instances in the specified accounts and Regions. If the stack
set update does not include changes to the template or parameters, CloudFormation updates
the stack instances in the specified accounts and Regions, while leaving all other stack
instances with their existing stack instance status.
- `"Tags"`: The key-value pairs to associate with this stack set and the stacks created
from it. CloudFormation also propagates these tags to supported resources that are created
in the stacks. You can specify a maximum number of 50 tags. If you specify tags for this
parameter, those tags replace any list of tags that are currently associated with this
stack set. This means: If you don't specify this parameter, CloudFormation doesn't modify
the stack's tags. If you specify any tags using this parameter, you must specify all the
tags that you want associated with this stack set, even tags you've specified before (for
example, when creating the stack set or during a previous update of the stack set.). Any
tags that you don't include in the updated list of tags are removed from the stack set, and
therefore from the stacks and resources as well. If you specify an empty value,
CloudFormation removes all currently associated tags. If you specify new tags as part of
an UpdateStackSet action, CloudFormation checks to see if you have the required IAM
permission to tag resources. If you omit tags that are currently associated with the stack
set from the list of tags you specify, CloudFormation assumes that you want to remove those
tags from the stack set, and checks to see if you have permission to untag resources. If
you don't have the necessary permission(s), the entire UpdateStackSet action fails with an
access denied error, and the stack set is not updated.
- `"TemplateBody"`: The structure that contains the template body, with a minimum length of
1 byte and a maximum length of 51,200 bytes. For more information, see Template Anatomy in
the CloudFormation User Guide. Conditional: You must specify only one of the following
parameters: TemplateBody or TemplateURL—or set UsePreviousTemplate to true.
- `"TemplateURL"`: The location of the file that contains the template body. The URL must
point to a template (maximum size: 460,800 bytes) that is located in an Amazon S3 bucket or
a Systems Manager document. For more information, see Template Anatomy in the
CloudFormation User Guide. Conditional: You must specify only one of the following
parameters: TemplateBody or TemplateURL—or set UsePreviousTemplate to true.
- `"UsePreviousTemplate"`: Use the existing template that's associated with the stack set
that you're updating. Conditional: You must specify only one of the following parameters:
TemplateBody or TemplateURL—or set UsePreviousTemplate to true.
"""
function update_stack_set(StackSetName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"UpdateStackSet",
Dict{String,Any}("StackSetName" => StackSetName, "OperationId" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_stack_set(
StackSetName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateStackSet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StackSetName" => StackSetName, "OperationId" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_termination_protection(enable_termination_protection, stack_name)
update_termination_protection(enable_termination_protection, stack_name, params::Dict{String,<:Any})
Updates termination protection for the specified stack. If a user attempts to delete a
stack with termination protection enabled, the operation fails and the stack remains
unchanged. For more information, see Protecting a Stack From Being Deleted in the
CloudFormation User Guide. For nested stacks, termination protection is set on the root
stack and can't be changed directly on the nested stack.
# Arguments
- `enable_termination_protection`: Whether to enable termination protection on the
specified stack.
- `stack_name`: The name or unique ID of the stack for which you want to set termination
protection.
"""
function update_termination_protection(
EnableTerminationProtection,
StackName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateTerminationProtection",
Dict{String,Any}(
"EnableTerminationProtection" => EnableTerminationProtection,
"StackName" => StackName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_termination_protection(
EnableTerminationProtection,
StackName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudformation(
"UpdateTerminationProtection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EnableTerminationProtection" => EnableTerminationProtection,
"StackName" => StackName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
validate_template()
validate_template(params::Dict{String,<:Any})
Validates a specified template. CloudFormation first checks if the template is valid JSON.
If it isn't, CloudFormation checks if the template is valid YAML. If both these checks
fail, CloudFormation returns a template validation error.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"TemplateBody"`: Structure containing the template body with a minimum length of 1 byte
and a maximum length of 51,200 bytes. For more information, go to Template Anatomy in the
CloudFormation User Guide. Conditional: You must pass TemplateURL or TemplateBody. If both
are passed, only TemplateBody is used.
- `"TemplateURL"`: Location of file containing the template body. The URL must point to a
template (max size: 460,800 bytes) that is located in an Amazon S3 bucket or a Systems
Manager document. For more information, go to Template Anatomy in the CloudFormation User
Guide. The location for an Amazon S3 bucket must start with https://. Conditional: You must
pass TemplateURL or TemplateBody. If both are passed, only TemplateBody is used.
"""
function validate_template(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudformation(
"ValidateTemplate"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function validate_template(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudformation(
"ValidateTemplate", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 173125 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudfront
using AWS.Compat
using AWS.UUIDs
"""
associate_alias2020_05_31(alias, target_distribution_id)
associate_alias2020_05_31(alias, target_distribution_id, params::Dict{String,<:Any})
Associates an alias (also known as a CNAME or an alternate domain name) with a CloudFront
distribution. With this operation you can move an alias that's already in use on a
CloudFront distribution to a different distribution in one step. This prevents the downtime
that could occur if you first remove the alias from one distribution and then separately
add the alias to another distribution. To use this operation to associate an alias with a
distribution, you provide the alias and the ID of the target distribution for the alias.
For more information, including how to set up the target distribution, prerequisites that
you must complete, and other restrictions, see Moving an alternate domain name to a
different distribution in the Amazon CloudFront Developer Guide.
# Arguments
- `alias`: The alias (also known as a CNAME) to add to the target distribution.
- `target_distribution_id`: The ID of the distribution that you're associating the alias
with.
"""
function associate_alias2020_05_31(
Alias, TargetDistributionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(TargetDistributionId)/associate-alias",
Dict{String,Any}("Alias" => Alias);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_alias2020_05_31(
Alias,
TargetDistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(TargetDistributionId)/associate-alias",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Alias" => Alias), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
copy_distribution2020_05_31(caller_reference, primary_distribution_id)
copy_distribution2020_05_31(caller_reference, primary_distribution_id, params::Dict{String,<:Any})
Creates a staging distribution using the configuration of the provided primary
distribution. A staging distribution is a copy of an existing distribution (called the
primary distribution) that you can use in a continuous deployment workflow. After you
create a staging distribution, you can use UpdateDistribution to modify the staging
distribution's configuration. Then you can use CreateContinuousDeploymentPolicy to
incrementally move traffic to the staging distribution. This API operation requires the
following IAM permissions: GetDistribution CreateDistribution CopyDistribution
# Arguments
- `caller_reference`: A value that uniquely identifies a request to create a resource. This
helps to prevent CloudFront from creating a duplicate resource if you accidentally resubmit
an identical request.
- `primary_distribution_id`: The identifier of the primary distribution whose configuration
you are copying. To get a distribution ID, use ListDistributions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Enabled"`: A Boolean flag to specify the state of the staging distribution when it's
created. When you set this value to True, the staging distribution is enabled. When you set
this value to False, the staging distribution is disabled. If you omit this field, the
default value is True.
- `"If-Match"`: The version identifier of the primary distribution whose configuration you
are copying. This is the ETag value returned in the response to GetDistribution and
GetDistributionConfig.
- `"Staging"`: The type of distribution that your primary distribution will be copied to.
The only valid value is True, indicating that you are copying to a staging distribution.
"""
function copy_distribution2020_05_31(
CallerReference,
PrimaryDistributionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distribution/$(PrimaryDistributionId)/copy",
Dict{String,Any}("CallerReference" => CallerReference);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function copy_distribution2020_05_31(
CallerReference,
PrimaryDistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distribution/$(PrimaryDistributionId)/copy",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("CallerReference" => CallerReference), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_cache_policy2020_05_31(cache_policy_config)
create_cache_policy2020_05_31(cache_policy_config, params::Dict{String,<:Any})
Creates a cache policy. After you create a cache policy, you can attach it to one or more
cache behaviors. When it's attached to a cache behavior, the cache policy determines the
following: The values that CloudFront includes in the cache key. These values can include
HTTP headers, cookies, and URL query strings. CloudFront uses the cache key to find an
object in its cache that it can return to the viewer. The default, minimum, and maximum
time to live (TTL) values that you want objects to stay in the CloudFront cache. The
headers, cookies, and query strings that are included in the cache key are also included in
requests that CloudFront sends to the origin. CloudFront sends a request when it can't find
an object in its cache that matches the request's cache key. If you want to send values to
the origin but not include them in the cache key, use OriginRequestPolicy. For more
information about cache policies, see Controlling the cache key in the Amazon CloudFront
Developer Guide.
# Arguments
- `cache_policy_config`: A cache policy configuration.
"""
function create_cache_policy2020_05_31(
CachePolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/cache-policy",
Dict{String,Any}("CachePolicyConfig" => CachePolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_cache_policy2020_05_31(
CachePolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/cache-policy",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("CachePolicyConfig" => CachePolicyConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_cloud_front_origin_access_identity2020_05_31(cloud_front_origin_access_identity_config)
create_cloud_front_origin_access_identity2020_05_31(cloud_front_origin_access_identity_config, params::Dict{String,<:Any})
Creates a new origin access identity. If you're using Amazon S3 for your origin, you can
use an origin access identity to require users to access your content using a CloudFront
URL instead of the Amazon S3 URL. For more information about how to use origin access
identities, see Serving Private Content through CloudFront in the Amazon CloudFront
Developer Guide.
# Arguments
- `cloud_front_origin_access_identity_config`: The current configuration information for
the identity.
"""
function create_cloud_front_origin_access_identity2020_05_31(
CloudFrontOriginAccessIdentityConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/origin-access-identity/cloudfront",
Dict{String,Any}(
"CloudFrontOriginAccessIdentityConfig" => CloudFrontOriginAccessIdentityConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_cloud_front_origin_access_identity2020_05_31(
CloudFrontOriginAccessIdentityConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/origin-access-identity/cloudfront",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CloudFrontOriginAccessIdentityConfig" =>
CloudFrontOriginAccessIdentityConfig,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_continuous_deployment_policy2020_05_31(continuous_deployment_policy_config)
create_continuous_deployment_policy2020_05_31(continuous_deployment_policy_config, params::Dict{String,<:Any})
Creates a continuous deployment policy that distributes traffic for a custom domain name to
two different CloudFront distributions. To use a continuous deployment policy, first use
CopyDistribution to create a staging distribution, then use UpdateDistribution to modify
the staging distribution's configuration. After you create and update a staging
distribution, you can use a continuous deployment policy to incrementally move traffic to
the staging distribution. This workflow enables you to test changes to a distribution's
configuration before moving all of your domain's production traffic to the new
configuration.
# Arguments
- `continuous_deployment_policy_config`: Contains the configuration for a continuous
deployment policy.
"""
function create_continuous_deployment_policy2020_05_31(
ContinuousDeploymentPolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/continuous-deployment-policy",
Dict{String,Any}(
"ContinuousDeploymentPolicyConfig" => ContinuousDeploymentPolicyConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_continuous_deployment_policy2020_05_31(
ContinuousDeploymentPolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/continuous-deployment-policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ContinuousDeploymentPolicyConfig" => ContinuousDeploymentPolicyConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_distribution2020_05_31(distribution_config)
create_distribution2020_05_31(distribution_config, params::Dict{String,<:Any})
Creates a CloudFront distribution.
# Arguments
- `distribution_config`: The distribution's configuration information.
"""
function create_distribution2020_05_31(
DistributionConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/distribution",
Dict{String,Any}("DistributionConfig" => DistributionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_distribution2020_05_31(
DistributionConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distribution",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("DistributionConfig" => DistributionConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_distribution_with_tags2020_05_31(distribution_config_with_tags)
create_distribution_with_tags2020_05_31(distribution_config_with_tags, params::Dict{String,<:Any})
Create a new distribution with tags. This API operation requires the following IAM
permissions: CreateDistribution TagResource
# Arguments
- `distribution_config_with_tags`: The distribution's configuration information.
"""
function create_distribution_with_tags2020_05_31(
DistributionConfigWithTags; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/distribution?WithTags",
Dict{String,Any}("DistributionConfigWithTags" => DistributionConfigWithTags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_distribution_with_tags2020_05_31(
DistributionConfigWithTags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distribution?WithTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DistributionConfigWithTags" => DistributionConfigWithTags
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_field_level_encryption_config2020_05_31(field_level_encryption_config)
create_field_level_encryption_config2020_05_31(field_level_encryption_config, params::Dict{String,<:Any})
Create a new field-level encryption configuration.
# Arguments
- `field_level_encryption_config`: The request to create a new field-level encryption
configuration.
"""
function create_field_level_encryption_config2020_05_31(
FieldLevelEncryptionConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/field-level-encryption",
Dict{String,Any}("FieldLevelEncryptionConfig" => FieldLevelEncryptionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_field_level_encryption_config2020_05_31(
FieldLevelEncryptionConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/field-level-encryption",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FieldLevelEncryptionConfig" => FieldLevelEncryptionConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_field_level_encryption_profile2020_05_31(field_level_encryption_profile_config)
create_field_level_encryption_profile2020_05_31(field_level_encryption_profile_config, params::Dict{String,<:Any})
Create a field-level encryption profile.
# Arguments
- `field_level_encryption_profile_config`: The request to create a field-level encryption
profile.
"""
function create_field_level_encryption_profile2020_05_31(
FieldLevelEncryptionProfileConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/field-level-encryption-profile",
Dict{String,Any}(
"FieldLevelEncryptionProfileConfig" => FieldLevelEncryptionProfileConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_field_level_encryption_profile2020_05_31(
FieldLevelEncryptionProfileConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/field-level-encryption-profile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FieldLevelEncryptionProfileConfig" => FieldLevelEncryptionProfileConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_function2020_05_31(function_code, function_config, name)
create_function2020_05_31(function_code, function_config, name, params::Dict{String,<:Any})
Creates a CloudFront function. To create a function, you provide the function code and some
configuration information about the function. The response contains an Amazon Resource Name
(ARN) that uniquely identifies the function. When you create a function, it's in the
DEVELOPMENT stage. In this stage, you can test the function with TestFunction, and update
it with UpdateFunction. When you're ready to use your function with a CloudFront
distribution, use PublishFunction to copy the function from the DEVELOPMENT stage to LIVE.
When it's live, you can attach the function to a distribution's cache behavior, using the
function's ARN.
# Arguments
- `function_code`: The function code. For more information about writing a CloudFront
function, see Writing function code for CloudFront Functions in the Amazon CloudFront
Developer Guide.
- `function_config`: Configuration information about the function, including an optional
comment and the function's runtime.
- `name`: A name to identify the function.
"""
function create_function2020_05_31(
FunctionCode, FunctionConfig, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/function",
Dict{String,Any}(
"FunctionCode" => FunctionCode,
"FunctionConfig" => FunctionConfig,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_function2020_05_31(
FunctionCode,
FunctionConfig,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/function",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FunctionCode" => FunctionCode,
"FunctionConfig" => FunctionConfig,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_invalidation2020_05_31(distribution_id, invalidation_batch)
create_invalidation2020_05_31(distribution_id, invalidation_batch, params::Dict{String,<:Any})
Create a new invalidation. For more information, see Invalidating files in the Amazon
CloudFront Developer Guide.
# Arguments
- `distribution_id`: The distribution's id.
- `invalidation_batch`: The batch information for the invalidation.
"""
function create_invalidation2020_05_31(
DistributionId, InvalidationBatch; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/distribution/$(DistributionId)/invalidation",
Dict{String,Any}("InvalidationBatch" => InvalidationBatch);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_invalidation2020_05_31(
DistributionId,
InvalidationBatch,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distribution/$(DistributionId)/invalidation",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("InvalidationBatch" => InvalidationBatch), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_key_group2020_05_31(key_group_config)
create_key_group2020_05_31(key_group_config, params::Dict{String,<:Any})
Creates a key group that you can use with CloudFront signed URLs and signed cookies. To
create a key group, you must specify at least one public key for the key group. After you
create a key group, you can reference it from one or more cache behaviors. When you
reference a key group in a cache behavior, CloudFront requires signed URLs or signed
cookies for all requests that match the cache behavior. The URLs or cookies must be signed
with a private key whose corresponding public key is in the key group. The signed URL or
cookie contains information about which public key CloudFront should use to verify the
signature. For more information, see Serving private content in the Amazon CloudFront
Developer Guide.
# Arguments
- `key_group_config`: A key group configuration.
"""
function create_key_group2020_05_31(
KeyGroupConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/key-group",
Dict{String,Any}("KeyGroupConfig" => KeyGroupConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_key_group2020_05_31(
KeyGroupConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/key-group",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("KeyGroupConfig" => KeyGroupConfig), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_key_value_store2020_05_31(name)
create_key_value_store2020_05_31(name, params::Dict{String,<:Any})
Specifies the key value store resource to add to your account. In your account, the key
value store names must be unique. You can also import key value store data in JSON format
from an S3 bucket by providing a valid ImportSource that you own.
# Arguments
- `name`: The name of the key value store. The minimum length is 1 character and the
maximum length is 64 characters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Comment"`: The comment of the key value store.
- `"ImportSource"`: The S3 bucket that provides the source for the import. The source must
be in a valid JSON format.
"""
function create_key_value_store2020_05_31(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/key-value-store/",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_key_value_store2020_05_31(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/key-value-store/",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_monitoring_subscription2020_05_31(distribution_id, monitoring_subscription)
create_monitoring_subscription2020_05_31(distribution_id, monitoring_subscription, params::Dict{String,<:Any})
Enables additional CloudWatch metrics for the specified CloudFront distribution. The
additional metrics incur an additional cost. For more information, see Viewing additional
CloudFront distribution metrics in the Amazon CloudFront Developer Guide.
# Arguments
- `distribution_id`: The ID of the distribution that you are enabling metrics for.
- `monitoring_subscription`: A monitoring subscription. This structure contains information
about whether additional CloudWatch metrics are enabled for a given CloudFront distribution.
"""
function create_monitoring_subscription2020_05_31(
DistributionId,
MonitoringSubscription;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/",
Dict{String,Any}("MonitoringSubscription" => MonitoringSubscription);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_monitoring_subscription2020_05_31(
DistributionId,
MonitoringSubscription,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("MonitoringSubscription" => MonitoringSubscription),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_origin_access_control2020_05_31(origin_access_control_config)
create_origin_access_control2020_05_31(origin_access_control_config, params::Dict{String,<:Any})
Creates a new origin access control in CloudFront. After you create an origin access
control, you can add it to an origin in a CloudFront distribution so that CloudFront sends
authenticated (signed) requests to the origin. This makes it possible to block public
access to the origin, allowing viewers (users) to access the origin's content only through
CloudFront. For more information about using a CloudFront origin access control, see
Restricting access to an Amazon Web Services origin in the Amazon CloudFront Developer
Guide.
# Arguments
- `origin_access_control_config`: Contains the origin access control.
"""
function create_origin_access_control2020_05_31(
OriginAccessControlConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/origin-access-control",
Dict{String,Any}("OriginAccessControlConfig" => OriginAccessControlConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_origin_access_control2020_05_31(
OriginAccessControlConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/origin-access-control",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("OriginAccessControlConfig" => OriginAccessControlConfig),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_origin_request_policy2020_05_31(origin_request_policy_config)
create_origin_request_policy2020_05_31(origin_request_policy_config, params::Dict{String,<:Any})
Creates an origin request policy. After you create an origin request policy, you can attach
it to one or more cache behaviors. When it's attached to a cache behavior, the origin
request policy determines the values that CloudFront includes in requests that it sends to
the origin. Each request that CloudFront sends to the origin includes the following: The
request body and the URL path (without the domain name) from the viewer request. The
headers that CloudFront automatically includes in every origin request, including Host,
User-Agent, and X-Amz-Cf-Id. All HTTP headers, cookies, and URL query strings that are
specified in the cache policy or the origin request policy. These can include items from
the viewer request and, in the case of headers, additional ones that are added by
CloudFront. CloudFront sends a request when it can't find a valid object in its cache
that matches the request. If you want to send values to the origin and also include them in
the cache key, use CachePolicy. For more information about origin request policies, see
Controlling origin requests in the Amazon CloudFront Developer Guide.
# Arguments
- `origin_request_policy_config`: An origin request policy configuration.
"""
function create_origin_request_policy2020_05_31(
OriginRequestPolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/origin-request-policy",
Dict{String,Any}("OriginRequestPolicyConfig" => OriginRequestPolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_origin_request_policy2020_05_31(
OriginRequestPolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/origin-request-policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("OriginRequestPolicyConfig" => OriginRequestPolicyConfig),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_public_key2020_05_31(public_key_config)
create_public_key2020_05_31(public_key_config, params::Dict{String,<:Any})
Uploads a public key to CloudFront that you can use with signed URLs and signed cookies, or
with field-level encryption.
# Arguments
- `public_key_config`: A CloudFront public key configuration.
"""
function create_public_key2020_05_31(
PublicKeyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/public-key",
Dict{String,Any}("PublicKeyConfig" => PublicKeyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_public_key2020_05_31(
PublicKeyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/public-key",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("PublicKeyConfig" => PublicKeyConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_realtime_log_config2020_05_31(end_points, field, name, sampling_rate)
create_realtime_log_config2020_05_31(end_points, field, name, sampling_rate, params::Dict{String,<:Any})
Creates a real-time log configuration. After you create a real-time log configuration, you
can attach it to one or more cache behaviors to send real-time log data to the specified
Amazon Kinesis data stream. For more information about real-time log configurations, see
Real-time logs in the Amazon CloudFront Developer Guide.
# Arguments
- `end_points`: Contains information about the Amazon Kinesis data stream where you are
sending real-time log data.
- `field`: A list of fields to include in each real-time log record. For more information
about fields, see Real-time log configuration fields in the Amazon CloudFront Developer
Guide.
- `name`: A unique name to identify this real-time log configuration.
- `sampling_rate`: The sampling rate for this real-time log configuration. You can specify
a whole number between 1 and 100 (inclusive) to determine the percentage of viewer requests
that are represented in the real-time log data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Fields"`: A list of fields to include in each real-time log record. For more
information about fields, see Real-time log configuration fields in the Amazon CloudFront
Developer Guide.
"""
function create_realtime_log_config2020_05_31(
EndPoints, Field, Name, SamplingRate; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/realtime-log-config",
Dict{String,Any}(
"EndPoints" => EndPoints,
"Field" => Field,
"Name" => Name,
"SamplingRate" => SamplingRate,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_realtime_log_config2020_05_31(
EndPoints,
Field,
Name,
SamplingRate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/realtime-log-config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndPoints" => EndPoints,
"Field" => Field,
"Name" => Name,
"SamplingRate" => SamplingRate,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_response_headers_policy2020_05_31(response_headers_policy_config)
create_response_headers_policy2020_05_31(response_headers_policy_config, params::Dict{String,<:Any})
Creates a response headers policy. A response headers policy contains information about a
set of HTTP headers. To create a response headers policy, you provide some metadata about
the policy and a set of configurations that specify the headers. After you create a
response headers policy, you can use its ID to attach it to one or more cache behaviors in
a CloudFront distribution. When it's attached to a cache behavior, the response headers
policy affects the HTTP headers that CloudFront includes in HTTP responses to requests that
match the cache behavior. CloudFront adds or removes response headers according to the
configuration of the response headers policy. For more information, see Adding or removing
HTTP headers in CloudFront responses in the Amazon CloudFront Developer Guide.
# Arguments
- `response_headers_policy_config`: Contains metadata about the response headers policy,
and a set of configurations that specify the HTTP headers.
"""
function create_response_headers_policy2020_05_31(
ResponseHeadersPolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/response-headers-policy",
Dict{String,Any}("ResponseHeadersPolicyConfig" => ResponseHeadersPolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_response_headers_policy2020_05_31(
ResponseHeadersPolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/response-headers-policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResponseHeadersPolicyConfig" => ResponseHeadersPolicyConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_streaming_distribution2020_05_31(streaming_distribution_config)
create_streaming_distribution2020_05_31(streaming_distribution_config, params::Dict{String,<:Any})
This API is deprecated. Amazon CloudFront is deprecating real-time messaging protocol
(RTMP) distributions on December 31, 2020. For more information, read the announcement on
the Amazon CloudFront discussion forum.
# Arguments
- `streaming_distribution_config`: The streaming distribution's configuration information.
"""
function create_streaming_distribution2020_05_31(
StreamingDistributionConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/streaming-distribution",
Dict{String,Any}("StreamingDistributionConfig" => StreamingDistributionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_streaming_distribution2020_05_31(
StreamingDistributionConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/streaming-distribution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StreamingDistributionConfig" => StreamingDistributionConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_streaming_distribution_with_tags2020_05_31(streaming_distribution_config_with_tags)
create_streaming_distribution_with_tags2020_05_31(streaming_distribution_config_with_tags, params::Dict{String,<:Any})
This API is deprecated. Amazon CloudFront is deprecating real-time messaging protocol
(RTMP) distributions on December 31, 2020. For more information, read the announcement on
the Amazon CloudFront discussion forum.
# Arguments
- `streaming_distribution_config_with_tags`: The streaming distribution's configuration
information.
"""
function create_streaming_distribution_with_tags2020_05_31(
StreamingDistributionConfigWithTags; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/streaming-distribution?WithTags",
Dict{String,Any}(
"StreamingDistributionConfigWithTags" => StreamingDistributionConfigWithTags
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_streaming_distribution_with_tags2020_05_31(
StreamingDistributionConfigWithTags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/streaming-distribution?WithTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StreamingDistributionConfigWithTags" =>
StreamingDistributionConfigWithTags,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_cache_policy2020_05_31(id)
delete_cache_policy2020_05_31(id, params::Dict{String,<:Any})
Deletes a cache policy. You cannot delete a cache policy if it's attached to a cache
behavior. First update your distributions to remove the cache policy from all cache
behaviors, then delete the cache policy. To delete a cache policy, you must provide the
policy's identifier and version. To get these values, you can use ListCachePolicies or
GetCachePolicy.
# Arguments
- `id`: The unique identifier for the cache policy that you are deleting. To get the
identifier, you can use ListCachePolicies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the cache policy that you are deleting. The version is the
cache policy's ETag value, which you can get using ListCachePolicies, GetCachePolicy, or
GetCachePolicyConfig.
"""
function delete_cache_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/cache-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_cache_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/cache-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_cloud_front_origin_access_identity2020_05_31(id)
delete_cloud_front_origin_access_identity2020_05_31(id, params::Dict{String,<:Any})
Delete an origin access identity.
# Arguments
- `id`: The origin access identity's ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header you received from a previous GET or PUT
request. For example: E2QWRUHAPOMQZL.
"""
function delete_cloud_front_origin_access_identity2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_cloud_front_origin_access_identity2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_continuous_deployment_policy2020_05_31(id)
delete_continuous_deployment_policy2020_05_31(id, params::Dict{String,<:Any})
Deletes a continuous deployment policy. You cannot delete a continuous deployment policy
that's attached to a primary distribution. First update your distribution to remove the
continuous deployment policy, then you can delete the policy.
# Arguments
- `id`: The identifier of the continuous deployment policy that you are deleting.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The current version (ETag value) of the continuous deployment policy that
you are deleting.
"""
function delete_continuous_deployment_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/continuous-deployment-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_continuous_deployment_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/continuous-deployment-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_distribution2020_05_31(id)
delete_distribution2020_05_31(id, params::Dict{String,<:Any})
Delete a distribution.
# Arguments
- `id`: The distribution ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when you disabled the
distribution. For example: E2QWRUHAPOMQZL.
"""
function delete_distribution2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/distribution/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_distribution2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/distribution/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_field_level_encryption_config2020_05_31(id)
delete_field_level_encryption_config2020_05_31(id, params::Dict{String,<:Any})
Remove a field-level encryption configuration.
# Arguments
- `id`: The ID of the configuration you want to delete from CloudFront.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the
configuration identity to delete. For example: E2QWRUHAPOMQZL.
"""
function delete_field_level_encryption_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/field-level-encryption/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_field_level_encryption_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/field-level-encryption/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_field_level_encryption_profile2020_05_31(id)
delete_field_level_encryption_profile2020_05_31(id, params::Dict{String,<:Any})
Remove a field-level encryption profile.
# Arguments
- `id`: Request the ID of the profile you want to delete from CloudFront.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the profile
to delete. For example: E2QWRUHAPOMQZL.
"""
function delete_field_level_encryption_profile2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/field-level-encryption-profile/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_field_level_encryption_profile2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/field-level-encryption-profile/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_function2020_05_31(if-_match, name)
delete_function2020_05_31(if-_match, name, params::Dict{String,<:Any})
Deletes a CloudFront function. You cannot delete a function if it's associated with a cache
behavior. First, update your distributions to remove the function association from all
cache behaviors, then delete the function. To delete a function, you must provide the
function's name and version (ETag value). To get these values, you can use ListFunctions
and DescribeFunction.
# Arguments
- `if-_match`: The current version (ETag value) of the function that you are deleting,
which you can get using DescribeFunction.
- `name`: The name of the function that you are deleting.
"""
function delete_function2020_05_31(
If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/function/$(Name)",
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_function2020_05_31(
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"DELETE",
"/2020-05-31/function/$(Name)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match)),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_key_group2020_05_31(id)
delete_key_group2020_05_31(id, params::Dict{String,<:Any})
Deletes a key group. You cannot delete a key group that is referenced in a cache behavior.
First update your distributions to remove the key group from all cache behaviors, then
delete the key group. To delete a key group, you must provide the key group's identifier
and version. To get these values, use ListKeyGroups followed by GetKeyGroup or
GetKeyGroupConfig.
# Arguments
- `id`: The identifier of the key group that you are deleting. To get the identifier, use
ListKeyGroups.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the key group that you are deleting. The version is the key
group's ETag value. To get the ETag, use GetKeyGroup or GetKeyGroupConfig.
"""
function delete_key_group2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"DELETE",
"/2020-05-31/key-group/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_key_group2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/key-group/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_key_value_store2020_05_31(if-_match, name)
delete_key_value_store2020_05_31(if-_match, name, params::Dict{String,<:Any})
Specifies the key value store to delete.
# Arguments
- `if-_match`: The key value store to delete, if a match occurs.
- `name`: The name of the key value store.
"""
function delete_key_value_store2020_05_31(
If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/key-value-store/$(Name)",
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_key_value_store2020_05_31(
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"DELETE",
"/2020-05-31/key-value-store/$(Name)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match)),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_monitoring_subscription2020_05_31(distribution_id)
delete_monitoring_subscription2020_05_31(distribution_id, params::Dict{String,<:Any})
Disables additional CloudWatch metrics for the specified CloudFront distribution.
# Arguments
- `distribution_id`: The ID of the distribution that you are disabling metrics for.
"""
function delete_monitoring_subscription2020_05_31(
DistributionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_monitoring_subscription2020_05_31(
DistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"DELETE",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_origin_access_control2020_05_31(id)
delete_origin_access_control2020_05_31(id, params::Dict{String,<:Any})
Deletes a CloudFront origin access control. You cannot delete an origin access control if
it's in use. First, update all distributions to remove the origin access control from all
origins, then delete the origin access control.
# Arguments
- `id`: The unique identifier of the origin access control that you are deleting.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The current version (ETag value) of the origin access control that you are
deleting.
"""
function delete_origin_access_control2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-access-control/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_origin_access_control2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-access-control/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_origin_request_policy2020_05_31(id)
delete_origin_request_policy2020_05_31(id, params::Dict{String,<:Any})
Deletes an origin request policy. You cannot delete an origin request policy if it's
attached to any cache behaviors. First update your distributions to remove the origin
request policy from all cache behaviors, then delete the origin request policy. To delete
an origin request policy, you must provide the policy's identifier and version. To get the
identifier, you can use ListOriginRequestPolicies or GetOriginRequestPolicy.
# Arguments
- `id`: The unique identifier for the origin request policy that you are deleting. To get
the identifier, you can use ListOriginRequestPolicies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the origin request policy that you are deleting. The version
is the origin request policy's ETag value, which you can get using
ListOriginRequestPolicies, GetOriginRequestPolicy, or GetOriginRequestPolicyConfig.
"""
function delete_origin_request_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-request-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_origin_request_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/origin-request-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_public_key2020_05_31(id)
delete_public_key2020_05_31(id, params::Dict{String,<:Any})
Remove a public key you previously added to CloudFront.
# Arguments
- `id`: The ID of the public key you want to remove from CloudFront.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the public
key identity to delete. For example: E2QWRUHAPOMQZL.
"""
function delete_public_key2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"DELETE",
"/2020-05-31/public-key/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_public_key2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/public-key/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_realtime_log_config2020_05_31()
delete_realtime_log_config2020_05_31(params::Dict{String,<:Any})
Deletes a real-time log configuration. You cannot delete a real-time log configuration if
it's attached to a cache behavior. First update your distributions to remove the real-time
log configuration from all cache behaviors, then delete the real-time log configuration. To
delete a real-time log configuration, you can provide the configuration's name or its
Amazon Resource Name (ARN). You must provide at least one. If you provide both, CloudFront
uses the name to identify the real-time log configuration to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ARN"`: The Amazon Resource Name (ARN) of the real-time log configuration to delete.
- `"Name"`: The name of the real-time log configuration to delete.
"""
function delete_realtime_log_config2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/delete-realtime-log-config/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_realtime_log_config2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/delete-realtime-log-config/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_response_headers_policy2020_05_31(id)
delete_response_headers_policy2020_05_31(id, params::Dict{String,<:Any})
Deletes a response headers policy. You cannot delete a response headers policy if it's
attached to a cache behavior. First update your distributions to remove the response
headers policy from all cache behaviors, then delete the response headers policy. To delete
a response headers policy, you must provide the policy's identifier and version. To get
these values, you can use ListResponseHeadersPolicies or GetResponseHeadersPolicy.
# Arguments
- `id`: The identifier for the response headers policy that you are deleting. To get the
identifier, you can use ListResponseHeadersPolicies.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the response headers policy that you are deleting. The
version is the response headers policy's ETag value, which you can get using
ListResponseHeadersPolicies, GetResponseHeadersPolicy, or GetResponseHeadersPolicyConfig.
"""
function delete_response_headers_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/response-headers-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_response_headers_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/response-headers-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_streaming_distribution2020_05_31(id)
delete_streaming_distribution2020_05_31(id, params::Dict{String,<:Any})
Delete a streaming distribution. To delete an RTMP distribution using the CloudFront API,
perform the following steps. To delete an RTMP distribution using the CloudFront API:
Disable the RTMP distribution. Submit a GET Streaming Distribution Config request to get
the current configuration and the Etag header for the distribution. Update the XML
document that was returned in the response to your GET Streaming Distribution Config
request to change the value of Enabled to false. Submit a PUT Streaming Distribution
Config request to update the configuration for your distribution. In the request body,
include the XML document that you updated in Step 3. Then set the value of the HTTP
If-Match header to the value of the ETag header that CloudFront returned when you submitted
the GET Streaming Distribution Config request in Step 2. Review the response to the PUT
Streaming Distribution Config request to confirm that the distribution was successfully
disabled. Submit a GET Streaming Distribution Config request to confirm that your changes
have propagated. When propagation is complete, the value of Status is Deployed. Submit a
DELETE Streaming Distribution request. Set the value of the HTTP If-Match header to the
value of the ETag header that CloudFront returned when you submitted the GET Streaming
Distribution Config request in Step 2. Review the response to your DELETE Streaming
Distribution request to confirm that the distribution was successfully deleted. For
information about deleting a distribution using the CloudFront console, see Deleting a
Distribution in the Amazon CloudFront Developer Guide.
# Arguments
- `id`: The distribution ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when you disabled the
streaming distribution. For example: E2QWRUHAPOMQZL.
"""
function delete_streaming_distribution2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/streaming-distribution/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_streaming_distribution2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"DELETE",
"/2020-05-31/streaming-distribution/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_function2020_05_31(name)
describe_function2020_05_31(name, params::Dict{String,<:Any})
Gets configuration information and metadata about a CloudFront function, but not the
function's code. To get a function's code, use GetFunction. To get configuration
information and metadata about a function, you must provide the function's name and stage.
To get these values, you can use ListFunctions.
# Arguments
- `name`: The name of the function that you are getting information about.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Stage"`: The function's stage, either DEVELOPMENT or LIVE.
"""
function describe_function2020_05_31(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/function/$(Name)/describe";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_function2020_05_31(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/function/$(Name)/describe",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_key_value_store2020_05_31(name)
describe_key_value_store2020_05_31(name, params::Dict{String,<:Any})
Specifies the key value store and its configuration.
# Arguments
- `name`: The name of the key value store.
"""
function describe_key_value_store2020_05_31(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-value-store/$(Name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_key_value_store2020_05_31(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-value-store/$(Name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_cache_policy2020_05_31(id)
get_cache_policy2020_05_31(id, params::Dict{String,<:Any})
Gets a cache policy, including the following metadata: The policy's identifier. The
date and time when the policy was last modified. To get a cache policy, you must provide
the policy's identifier. If the cache policy is attached to a distribution's cache
behavior, you can get the policy's identifier using ListDistributions or GetDistribution.
If the cache policy is not attached to a cache behavior, you can get the identifier using
ListCachePolicies.
# Arguments
- `id`: The unique identifier for the cache policy. If the cache policy is attached to a
distribution's cache behavior, you can get the policy's identifier using ListDistributions
or GetDistribution. If the cache policy is not attached to a cache behavior, you can get
the identifier using ListCachePolicies.
"""
function get_cache_policy2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/cache-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_cache_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/cache-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_cache_policy_config2020_05_31(id)
get_cache_policy_config2020_05_31(id, params::Dict{String,<:Any})
Gets a cache policy configuration. To get a cache policy configuration, you must provide
the policy's identifier. If the cache policy is attached to a distribution's cache
behavior, you can get the policy's identifier using ListDistributions or GetDistribution.
If the cache policy is not attached to a cache behavior, you can get the identifier using
ListCachePolicies.
# Arguments
- `id`: The unique identifier for the cache policy. If the cache policy is attached to a
distribution's cache behavior, you can get the policy's identifier using ListDistributions
or GetDistribution. If the cache policy is not attached to a cache behavior, you can get
the identifier using ListCachePolicies.
"""
function get_cache_policy_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/cache-policy/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_cache_policy_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/cache-policy/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_cloud_front_origin_access_identity2020_05_31(id)
get_cloud_front_origin_access_identity2020_05_31(id, params::Dict{String,<:Any})
Get the information about an origin access identity.
# Arguments
- `id`: The identity's ID.
"""
function get_cloud_front_origin_access_identity2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_cloud_front_origin_access_identity2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_cloud_front_origin_access_identity_config2020_05_31(id)
get_cloud_front_origin_access_identity_config2020_05_31(id, params::Dict{String,<:Any})
Get the configuration information about an origin access identity.
# Arguments
- `id`: The identity's ID.
"""
function get_cloud_front_origin_access_identity_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_cloud_front_origin_access_identity_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_continuous_deployment_policy2020_05_31(id)
get_continuous_deployment_policy2020_05_31(id, params::Dict{String,<:Any})
Gets a continuous deployment policy, including metadata (the policy's identifier and the
date and time when the policy was last modified).
# Arguments
- `id`: The identifier of the continuous deployment policy that you are getting.
"""
function get_continuous_deployment_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_continuous_deployment_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_continuous_deployment_policy_config2020_05_31(id)
get_continuous_deployment_policy_config2020_05_31(id, params::Dict{String,<:Any})
Gets configuration information about a continuous deployment policy.
# Arguments
- `id`: The identifier of the continuous deployment policy whose configuration you are
getting.
"""
function get_continuous_deployment_policy_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_continuous_deployment_policy_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_distribution2020_05_31(id)
get_distribution2020_05_31(id, params::Dict{String,<:Any})
Get the information about a distribution.
# Arguments
- `id`: The distribution's ID. If the ID is empty, an empty distribution configuration is
returned.
"""
function get_distribution2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/distribution/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_distribution2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_distribution_config2020_05_31(id)
get_distribution_config2020_05_31(id, params::Dict{String,<:Any})
Get the configuration information about a distribution.
# Arguments
- `id`: The distribution's ID. If the ID is empty, an empty distribution configuration is
returned.
"""
function get_distribution_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_distribution_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_field_level_encryption2020_05_31(id)
get_field_level_encryption2020_05_31(id, params::Dict{String,<:Any})
Get the field-level encryption configuration information.
# Arguments
- `id`: Request the ID for the field-level encryption configuration information.
"""
function get_field_level_encryption2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_field_level_encryption2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_field_level_encryption_config2020_05_31(id)
get_field_level_encryption_config2020_05_31(id, params::Dict{String,<:Any})
Get the field-level encryption configuration information.
# Arguments
- `id`: Request the ID for the field-level encryption configuration information.
"""
function get_field_level_encryption_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_field_level_encryption_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_field_level_encryption_profile2020_05_31(id)
get_field_level_encryption_profile2020_05_31(id, params::Dict{String,<:Any})
Get the field-level encryption profile information.
# Arguments
- `id`: Get the ID for the field-level encryption profile information.
"""
function get_field_level_encryption_profile2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_field_level_encryption_profile2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_field_level_encryption_profile_config2020_05_31(id)
get_field_level_encryption_profile_config2020_05_31(id, params::Dict{String,<:Any})
Get the field-level encryption profile configuration information.
# Arguments
- `id`: Get the ID for the field-level encryption profile configuration information.
"""
function get_field_level_encryption_profile_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_field_level_encryption_profile_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_function2020_05_31(name)
get_function2020_05_31(name, params::Dict{String,<:Any})
Gets the code of a CloudFront function. To get configuration information and metadata about
a function, use DescribeFunction. To get a function's code, you must provide the function's
name and stage. To get these values, you can use ListFunctions.
# Arguments
- `name`: The name of the function whose code you are getting.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Stage"`: The function's stage, either DEVELOPMENT or LIVE.
"""
function get_function2020_05_31(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/function/$(Name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_function2020_05_31(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/function/$(Name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_invalidation2020_05_31(distribution_id, id)
get_invalidation2020_05_31(distribution_id, id, params::Dict{String,<:Any})
Get the information about an invalidation.
# Arguments
- `distribution_id`: The distribution's ID.
- `id`: The identifier for the invalidation request, for example, IDFDVBD632BHDS5.
"""
function get_invalidation2020_05_31(
DistributionId, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(DistributionId)/invalidation/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_invalidation2020_05_31(
DistributionId,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(DistributionId)/invalidation/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_key_group2020_05_31(id)
get_key_group2020_05_31(id, params::Dict{String,<:Any})
Gets a key group, including the date and time when the key group was last modified. To get
a key group, you must provide the key group's identifier. If the key group is referenced in
a distribution's cache behavior, you can get the key group's identifier using
ListDistributions or GetDistribution. If the key group is not referenced in a cache
behavior, you can get the identifier using ListKeyGroups.
# Arguments
- `id`: The identifier of the key group that you are getting. To get the identifier, use
ListKeyGroups.
"""
function get_key_group2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/key-group/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_key_group2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-group/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_key_group_config2020_05_31(id)
get_key_group_config2020_05_31(id, params::Dict{String,<:Any})
Gets a key group configuration. To get a key group configuration, you must provide the key
group's identifier. If the key group is referenced in a distribution's cache behavior, you
can get the key group's identifier using ListDistributions or GetDistribution. If the key
group is not referenced in a cache behavior, you can get the identifier using ListKeyGroups.
# Arguments
- `id`: The identifier of the key group whose configuration you are getting. To get the
identifier, use ListKeyGroups.
"""
function get_key_group_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-group/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_key_group_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-group/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_monitoring_subscription2020_05_31(distribution_id)
get_monitoring_subscription2020_05_31(distribution_id, params::Dict{String,<:Any})
Gets information about whether additional CloudWatch metrics are enabled for the specified
CloudFront distribution.
# Arguments
- `distribution_id`: The ID of the distribution that you are getting metrics information
for.
"""
function get_monitoring_subscription2020_05_31(
DistributionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_monitoring_subscription2020_05_31(
DistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributions/$(DistributionId)/monitoring-subscription/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_origin_access_control2020_05_31(id)
get_origin_access_control2020_05_31(id, params::Dict{String,<:Any})
Gets a CloudFront origin access control, including its unique identifier.
# Arguments
- `id`: The unique identifier of the origin access control.
"""
function get_origin_access_control2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_origin_access_control2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_origin_access_control_config2020_05_31(id)
get_origin_access_control_config2020_05_31(id, params::Dict{String,<:Any})
Gets a CloudFront origin access control configuration.
# Arguments
- `id`: The unique identifier of the origin access control.
"""
function get_origin_access_control_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_origin_access_control_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_origin_request_policy2020_05_31(id)
get_origin_request_policy2020_05_31(id, params::Dict{String,<:Any})
Gets an origin request policy, including the following metadata: The policy's identifier.
The date and time when the policy was last modified. To get an origin request policy,
you must provide the policy's identifier. If the origin request policy is attached to a
distribution's cache behavior, you can get the policy's identifier using ListDistributions
or GetDistribution. If the origin request policy is not attached to a cache behavior, you
can get the identifier using ListOriginRequestPolicies.
# Arguments
- `id`: The unique identifier for the origin request policy. If the origin request policy
is attached to a distribution's cache behavior, you can get the policy's identifier using
ListDistributions or GetDistribution. If the origin request policy is not attached to a
cache behavior, you can get the identifier using ListOriginRequestPolicies.
"""
function get_origin_request_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_origin_request_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_origin_request_policy_config2020_05_31(id)
get_origin_request_policy_config2020_05_31(id, params::Dict{String,<:Any})
Gets an origin request policy configuration. To get an origin request policy configuration,
you must provide the policy's identifier. If the origin request policy is attached to a
distribution's cache behavior, you can get the policy's identifier using ListDistributions
or GetDistribution. If the origin request policy is not attached to a cache behavior, you
can get the identifier using ListOriginRequestPolicies.
# Arguments
- `id`: The unique identifier for the origin request policy. If the origin request policy
is attached to a distribution's cache behavior, you can get the policy's identifier using
ListDistributions or GetDistribution. If the origin request policy is not attached to a
cache behavior, you can get the identifier using ListOriginRequestPolicies.
"""
function get_origin_request_policy_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_origin_request_policy_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_public_key2020_05_31(id)
get_public_key2020_05_31(id, params::Dict{String,<:Any})
Gets a public key.
# Arguments
- `id`: The identifier of the public key you are getting.
"""
function get_public_key2020_05_31(Id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/public-key/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_public_key2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/public-key/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_public_key_config2020_05_31(id)
get_public_key_config2020_05_31(id, params::Dict{String,<:Any})
Gets a public key configuration.
# Arguments
- `id`: The identifier of the public key whose configuration you are getting.
"""
function get_public_key_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/public-key/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_public_key_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/public-key/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_realtime_log_config2020_05_31()
get_realtime_log_config2020_05_31(params::Dict{String,<:Any})
Gets a real-time log configuration. To get a real-time log configuration, you can provide
the configuration's name or its Amazon Resource Name (ARN). You must provide at least one.
If you provide both, CloudFront uses the name to identify the real-time log configuration
to get.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ARN"`: The Amazon Resource Name (ARN) of the real-time log configuration to get.
- `"Name"`: The name of the real-time log configuration to get.
"""
function get_realtime_log_config2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/get-realtime-log-config/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_realtime_log_config2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/get-realtime-log-config/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_response_headers_policy2020_05_31(id)
get_response_headers_policy2020_05_31(id, params::Dict{String,<:Any})
Gets a response headers policy, including metadata (the policy's identifier and the date
and time when the policy was last modified). To get a response headers policy, you must
provide the policy's identifier. If the response headers policy is attached to a
distribution's cache behavior, you can get the policy's identifier using ListDistributions
or GetDistribution. If the response headers policy is not attached to a cache behavior, you
can get the identifier using ListResponseHeadersPolicies.
# Arguments
- `id`: The identifier for the response headers policy. If the response headers policy is
attached to a distribution's cache behavior, you can get the policy's identifier using
ListDistributions or GetDistribution. If the response headers policy is not attached to a
cache behavior, you can get the identifier using ListResponseHeadersPolicies.
"""
function get_response_headers_policy2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_response_headers_policy2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_response_headers_policy_config2020_05_31(id)
get_response_headers_policy_config2020_05_31(id, params::Dict{String,<:Any})
Gets a response headers policy configuration. To get a response headers policy
configuration, you must provide the policy's identifier. If the response headers policy is
attached to a distribution's cache behavior, you can get the policy's identifier using
ListDistributions or GetDistribution. If the response headers policy is not attached to a
cache behavior, you can get the identifier using ListResponseHeadersPolicies.
# Arguments
- `id`: The identifier for the response headers policy. If the response headers policy is
attached to a distribution's cache behavior, you can get the policy's identifier using
ListDistributions or GetDistribution. If the response headers policy is not attached to a
cache behavior, you can get the identifier using ListResponseHeadersPolicies.
"""
function get_response_headers_policy_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_response_headers_policy_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_streaming_distribution2020_05_31(id)
get_streaming_distribution2020_05_31(id, params::Dict{String,<:Any})
Gets information about a specified RTMP distribution, including the distribution
configuration.
# Arguments
- `id`: The streaming distribution's ID.
"""
function get_streaming_distribution2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution/$(Id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_streaming_distribution2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution/$(Id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_streaming_distribution_config2020_05_31(id)
get_streaming_distribution_config2020_05_31(id, params::Dict{String,<:Any})
Get the configuration information about a streaming distribution.
# Arguments
- `id`: The streaming distribution's ID.
"""
function get_streaming_distribution_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution/$(Id)/config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_streaming_distribution_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution/$(Id)/config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_cache_policies2020_05_31()
list_cache_policies2020_05_31(params::Dict{String,<:Any})
Gets a list of cache policies. You can optionally apply a filter to return only the managed
policies created by Amazon Web Services, or only the custom policies created in your Amazon
Web Services account. You can optionally specify the maximum number of items to receive in
the response. If the total number of items in the list exceeds the maximum that you
specify, or the default maximum, the response is paginated. To get the next page of items,
send a subsequent request that specifies the NextMarker value from the current response as
the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of cache policies. The response includes cache policies in the list that occur after
the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of cache policies that you want in the response.
- `"Type"`: A filter to return only the specified kinds of cache policies. Valid values
are: managed – Returns only the managed policies created by Amazon Web Services.
custom – Returns only the custom policies created in your Amazon Web Services account.
"""
function list_cache_policies2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/cache-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_cache_policies2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/cache-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_cloud_front_origin_access_identities2020_05_31()
list_cloud_front_origin_access_identities2020_05_31(params::Dict{String,<:Any})
Lists origin access identities.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this when paginating results to indicate where to begin in your list of
origin access identities. The results include identities in the list that occur after the
marker. To get the next page of results, set the Marker to the value of the NextMarker from
the current page's response (which is also the ID of the last identity on that page).
- `"MaxItems"`: The maximum number of origin access identities you want in the response
body.
"""
function list_cloud_front_origin_access_identities2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_cloud_front_origin_access_identities2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-identity/cloudfront",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_conflicting_aliases2020_05_31(alias, distribution_id)
list_conflicting_aliases2020_05_31(alias, distribution_id, params::Dict{String,<:Any})
Gets a list of aliases (also called CNAMEs or alternate domain names) that conflict or
overlap with the provided alias, and the associated CloudFront distributions and Amazon Web
Services accounts for each conflicting alias. In the returned list, the distribution and
account IDs are partially hidden, which allows you to identify the distributions and
accounts that you own, but helps to protect the information of ones that you don't own. Use
this operation to find aliases that are in use in CloudFront that conflict or overlap with
the provided alias. For example, if you provide www.example.com as input, the returned list
can include www.example.com and the overlapping wildcard alternate domain name
(*.example.com), if they exist. If you provide *.example.com as input, the returned list
can include *.example.com and any alternate domain names covered by that wildcard (for
example, www.example.com, test.example.com, dev.example.com, and so on), if they exist. To
list conflicting aliases, you provide the alias to search and the ID of a distribution in
your account that has an attached SSL/TLS certificate that includes the provided alias. For
more information, including how to set up the distribution and certificate, see Moving an
alternate domain name to a different distribution in the Amazon CloudFront Developer Guide.
You can optionally specify the maximum number of items to receive in the response. If the
total number of items in the list exceeds the maximum that you specify, or the default
maximum, the response is paginated. To get the next page of items, send a subsequent
request that specifies the NextMarker value from the current response as the Marker value
in the subsequent request.
# Arguments
- `alias`: The alias (also called a CNAME) to search for conflicting aliases.
- `distribution_id`: The ID of a distribution in your account that has an attached SSL/TLS
certificate that includes the provided alias.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in the list
of conflicting aliases. The response includes conflicting aliases in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of conflicting aliases that you want in the response.
"""
function list_conflicting_aliases2020_05_31(
Alias, DistributionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/conflicting-alias",
Dict{String,Any}("Alias" => Alias, "DistributionId" => DistributionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_conflicting_aliases2020_05_31(
Alias,
DistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/conflicting-alias",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Alias" => Alias, "DistributionId" => DistributionId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_continuous_deployment_policies2020_05_31()
list_continuous_deployment_policies2020_05_31(params::Dict{String,<:Any})
Gets a list of the continuous deployment policies in your Amazon Web Services account. You
can optionally specify the maximum number of items to receive in the response. If the total
number of items in the list exceeds the maximum that you specify, or the default maximum,
the response is paginated. To get the next page of items, send a subsequent request that
specifies the NextMarker value from the current response as the Marker value in the
subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of continuous deployment policies. The response includes policies in the list that
occur after the marker. To get the next page of the list, set this field's value to the
value of NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of continuous deployment policies that you want returned
in the response.
"""
function list_continuous_deployment_policies2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_continuous_deployment_policies2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/continuous-deployment-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions2020_05_31()
list_distributions2020_05_31(params::Dict{String,<:Any})
List CloudFront distributions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this when paginating results to indicate where to begin in your list of
distributions. The results include distributions in the list that occur after the marker.
To get the next page of results, set the Marker to the value of the NextMarker from the
current page's response (which is also the ID of the last distribution on that page).
- `"MaxItems"`: The maximum number of distributions you want in the response body.
"""
function list_distributions2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/distribution";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_cache_policy_id2020_05_31(cache_policy_id)
list_distributions_by_cache_policy_id2020_05_31(cache_policy_id, params::Dict{String,<:Any})
Gets a list of distribution IDs for distributions that have a cache behavior that's
associated with the specified cache policy. You can optionally specify the maximum number
of items to receive in the response. If the total number of items in the list exceeds the
maximum that you specify, or the default maximum, the response is paginated. To get the
next page of items, send a subsequent request that specifies the NextMarker value from the
current response as the Marker value in the subsequent request.
# Arguments
- `cache_policy_id`: The ID of the cache policy whose associated distribution IDs you want
to list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of distribution IDs. The response includes distribution IDs in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of distribution IDs that you want in the response.
"""
function list_distributions_by_cache_policy_id2020_05_31(
CachePolicyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByCachePolicyId/$(CachePolicyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_cache_policy_id2020_05_31(
CachePolicyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByCachePolicyId/$(CachePolicyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_key_group2020_05_31(key_group_id)
list_distributions_by_key_group2020_05_31(key_group_id, params::Dict{String,<:Any})
Gets a list of distribution IDs for distributions that have a cache behavior that
references the specified key group. You can optionally specify the maximum number of items
to receive in the response. If the total number of items in the list exceeds the maximum
that you specify, or the default maximum, the response is paginated. To get the next page
of items, send a subsequent request that specifies the NextMarker value from the current
response as the Marker value in the subsequent request.
# Arguments
- `key_group_id`: The ID of the key group whose associated distribution IDs you are listing.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of distribution IDs. The response includes distribution IDs in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of distribution IDs that you want in the response.
"""
function list_distributions_by_key_group2020_05_31(
KeyGroupId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByKeyGroupId/$(KeyGroupId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_key_group2020_05_31(
KeyGroupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByKeyGroupId/$(KeyGroupId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_origin_request_policy_id2020_05_31(origin_request_policy_id)
list_distributions_by_origin_request_policy_id2020_05_31(origin_request_policy_id, params::Dict{String,<:Any})
Gets a list of distribution IDs for distributions that have a cache behavior that's
associated with the specified origin request policy. You can optionally specify the maximum
number of items to receive in the response. If the total number of items in the list
exceeds the maximum that you specify, or the default maximum, the response is paginated. To
get the next page of items, send a subsequent request that specifies the NextMarker value
from the current response as the Marker value in the subsequent request.
# Arguments
- `origin_request_policy_id`: The ID of the origin request policy whose associated
distribution IDs you want to list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of distribution IDs. The response includes distribution IDs in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of distribution IDs that you want in the response.
"""
function list_distributions_by_origin_request_policy_id2020_05_31(
OriginRequestPolicyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByOriginRequestPolicyId/$(OriginRequestPolicyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_origin_request_policy_id2020_05_31(
OriginRequestPolicyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByOriginRequestPolicyId/$(OriginRequestPolicyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_realtime_log_config2020_05_31()
list_distributions_by_realtime_log_config2020_05_31(params::Dict{String,<:Any})
Gets a list of distributions that have a cache behavior that's associated with the
specified real-time log configuration. You can specify the real-time log configuration by
its name or its Amazon Resource Name (ARN). You must provide at least one. If you provide
both, CloudFront uses the name to identify the real-time log configuration to list
distributions for. You can optionally specify the maximum number of items to receive in the
response. If the total number of items in the list exceeds the maximum that you specify, or
the default maximum, the response is paginated. To get the next page of items, send a
subsequent request that specifies the NextMarker value from the current response as the
Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of distributions. The response includes distributions in the list that occur after the
marker. To get the next page of the list, set this field's value to the value of NextMarker
from the current page's response.
- `"MaxItems"`: The maximum number of distributions that you want in the response.
- `"RealtimeLogConfigArn"`: The Amazon Resource Name (ARN) of the real-time log
configuration whose associated distributions you want to list.
- `"RealtimeLogConfigName"`: The name of the real-time log configuration whose associated
distributions you want to list.
"""
function list_distributions_by_realtime_log_config2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/distributionsByRealtimeLogConfig/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_realtime_log_config2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/distributionsByRealtimeLogConfig/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_response_headers_policy_id2020_05_31(response_headers_policy_id)
list_distributions_by_response_headers_policy_id2020_05_31(response_headers_policy_id, params::Dict{String,<:Any})
Gets a list of distribution IDs for distributions that have a cache behavior that's
associated with the specified response headers policy. You can optionally specify the
maximum number of items to receive in the response. If the total number of items in the
list exceeds the maximum that you specify, or the default maximum, the response is
paginated. To get the next page of items, send a subsequent request that specifies the
NextMarker value from the current response as the Marker value in the subsequent request.
# Arguments
- `response_headers_policy_id`: The ID of the response headers policy whose associated
distribution IDs you want to list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of distribution IDs. The response includes distribution IDs in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of distribution IDs that you want to get in the response.
"""
function list_distributions_by_response_headers_policy_id2020_05_31(
ResponseHeadersPolicyId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByResponseHeadersPolicyId/$(ResponseHeadersPolicyId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_response_headers_policy_id2020_05_31(
ResponseHeadersPolicyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByResponseHeadersPolicyId/$(ResponseHeadersPolicyId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_distributions_by_web_aclid2020_05_31(web_aclid)
list_distributions_by_web_aclid2020_05_31(web_aclid, params::Dict{String,<:Any})
List the distributions that are associated with a specified WAF web ACL.
# Arguments
- `web_aclid`: The ID of the WAF web ACL that you want to list the associated
distributions. If you specify \"null\" for the ID, the request returns a list of the
distributions that aren't associated with a web ACL. For WAFV2, this is the ARN of the web
ACL, such as
arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/a1b2c3d4-5678-90ab-cdef-EXA
MPLE11111. For WAF Classic, this is the ID of the web ACL, such as
a1b2c3d4-5678-90ab-cdef-EXAMPLE11111.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use Marker and MaxItems to control pagination of results. If you have more
than MaxItems distributions that satisfy the request, the response includes a NextMarker
element. To get the next page of results, submit another request. For the value of Marker,
specify the value of NextMarker from the last response. (For the first request, omit
Marker.)
- `"MaxItems"`: The maximum number of distributions that you want CloudFront to return in
the response body. The maximum and default values are both 100.
"""
function list_distributions_by_web_aclid2020_05_31(
WebACLId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByWebACLId/$(WebACLId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_distributions_by_web_aclid2020_05_31(
WebACLId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distributionsByWebACLId/$(WebACLId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_field_level_encryption_configs2020_05_31()
list_field_level_encryption_configs2020_05_31(params::Dict{String,<:Any})
List all field-level encryption configurations that have been created in CloudFront for
this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this when paginating results to indicate where to begin in your list of
configurations. The results include configurations in the list that occur after the marker.
To get the next page of results, set the Marker to the value of the NextMarker from the
current page's response (which is also the ID of the last configuration on that page).
- `"MaxItems"`: The maximum number of field-level encryption configurations you want in the
response body.
"""
function list_field_level_encryption_configs2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_field_level_encryption_configs2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_field_level_encryption_profiles2020_05_31()
list_field_level_encryption_profiles2020_05_31(params::Dict{String,<:Any})
Request a list of field-level encryption profiles that have been created in CloudFront for
this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this when paginating results to indicate where to begin in your list of
profiles. The results include profiles in the list that occur after the marker. To get the
next page of results, set the Marker to the value of the NextMarker from the current page's
response (which is also the ID of the last profile on that page).
- `"MaxItems"`: The maximum number of field-level encryption profiles you want in the
response body.
"""
function list_field_level_encryption_profiles2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_field_level_encryption_profiles2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/field-level-encryption-profile",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_functions2020_05_31()
list_functions2020_05_31(params::Dict{String,<:Any})
Gets a list of all CloudFront functions in your Amazon Web Services account. You can
optionally apply a filter to return only the functions that are in the specified stage,
either DEVELOPMENT or LIVE. You can optionally specify the maximum number of items to
receive in the response. If the total number of items in the list exceeds the maximum that
you specify, or the default maximum, the response is paginated. To get the next page of
items, send a subsequent request that specifies the NextMarker value from the current
response as the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of functions. The response includes functions in the list that occur after the marker.
To get the next page of the list, set this field's value to the value of NextMarker from
the current page's response.
- `"MaxItems"`: The maximum number of functions that you want in the response.
- `"Stage"`: An optional filter to return only the functions that are in the specified
stage, either DEVELOPMENT or LIVE.
"""
function list_functions2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/function";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_functions2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/function",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_invalidations2020_05_31(distribution_id)
list_invalidations2020_05_31(distribution_id, params::Dict{String,<:Any})
Lists invalidation batches.
# Arguments
- `distribution_id`: The distribution's ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this parameter when paginating results to indicate where to begin in your
list of invalidation batches. Because the results are returned in decreasing order from
most recent to oldest, the most recent results are on the first page, the second page will
contain earlier results, and so on. To get the next page of results, set Marker to the
value of the NextMarker from the current page's response. This value is the same as the ID
of the last invalidation batch on that page.
- `"MaxItems"`: The maximum number of invalidation batches that you want in the response
body.
"""
function list_invalidations2020_05_31(
DistributionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(DistributionId)/invalidation";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_invalidations2020_05_31(
DistributionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/distribution/$(DistributionId)/invalidation",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_key_groups2020_05_31()
list_key_groups2020_05_31(params::Dict{String,<:Any})
Gets a list of key groups. You can optionally specify the maximum number of items to
receive in the response. If the total number of items in the list exceeds the maximum that
you specify, or the default maximum, the response is paginated. To get the next page of
items, send a subsequent request that specifies the NextMarker value from the current
response as the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of key groups. The response includes key groups in the list that occur after the
marker. To get the next page of the list, set this field's value to the value of NextMarker
from the current page's response.
- `"MaxItems"`: The maximum number of key groups that you want in the response.
"""
function list_key_groups2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/key-group";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_key_groups2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-group",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_key_value_stores2020_05_31()
list_key_value_stores2020_05_31(params::Dict{String,<:Any})
Specifies the key value stores to list.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: The marker associated with the key value stores list.
- `"MaxItems"`: The maximum number of items in the key value stores list.
- `"Status"`: The status of the request for the key value stores list.
"""
function list_key_value_stores2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-value-store";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_key_value_stores2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/key-value-store",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_origin_access_controls2020_05_31()
list_origin_access_controls2020_05_31(params::Dict{String,<:Any})
Gets the list of CloudFront origin access controls in this Amazon Web Services account. You
can optionally specify the maximum number of items to receive in the response. If the total
number of items in the list exceeds the maximum that you specify, or the default maximum,
the response is paginated. To get the next page of items, send another request that
specifies the NextMarker value from the current response as the Marker value in the next
request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of origin access controls. The response includes the items in the list that occur
after the marker. To get the next page of the list, set this field's value to the value of
NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of origin access controls that you want in the response.
"""
function list_origin_access_controls2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_origin_access_controls2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-access-control",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_origin_request_policies2020_05_31()
list_origin_request_policies2020_05_31(params::Dict{String,<:Any})
Gets a list of origin request policies. You can optionally apply a filter to return only
the managed policies created by Amazon Web Services, or only the custom policies created in
your Amazon Web Services account. You can optionally specify the maximum number of items to
receive in the response. If the total number of items in the list exceeds the maximum that
you specify, or the default maximum, the response is paginated. To get the next page of
items, send a subsequent request that specifies the NextMarker value from the current
response as the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of origin request policies. The response includes origin request policies in the list
that occur after the marker. To get the next page of the list, set this field's value to
the value of NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of origin request policies that you want in the response.
- `"Type"`: A filter to return only the specified kinds of origin request policies. Valid
values are: managed – Returns only the managed policies created by Amazon Web
Services. custom – Returns only the custom policies created in your Amazon Web
Services account.
"""
function list_origin_request_policies2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_origin_request_policies2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/origin-request-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_public_keys2020_05_31()
list_public_keys2020_05_31(params::Dict{String,<:Any})
List all public keys that have been added to CloudFront for this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this when paginating results to indicate where to begin in your list of
public keys. The results include public keys in the list that occur after the marker. To
get the next page of results, set the Marker to the value of the NextMarker from the
current page's response (which is also the ID of the last public key on that page).
- `"MaxItems"`: The maximum number of public keys you want in the response body.
"""
function list_public_keys2020_05_31(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudfront(
"GET",
"/2020-05-31/public-key";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_public_keys2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/public-key",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_realtime_log_configs2020_05_31()
list_realtime_log_configs2020_05_31(params::Dict{String,<:Any})
Gets a list of real-time log configurations. You can optionally specify the maximum number
of items to receive in the response. If the total number of items in the list exceeds the
maximum that you specify, or the default maximum, the response is paginated. To get the
next page of items, send a subsequent request that specifies the NextMarker value from the
current response as the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of real-time log configurations. The response includes real-time log configurations in
the list that occur after the marker. To get the next page of the list, set this field's
value to the value of NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of real-time log configurations that you want in the
response.
"""
function list_realtime_log_configs2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/realtime-log-config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_realtime_log_configs2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/realtime-log-config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_response_headers_policies2020_05_31()
list_response_headers_policies2020_05_31(params::Dict{String,<:Any})
Gets a list of response headers policies. You can optionally apply a filter to get only the
managed policies created by Amazon Web Services, or only the custom policies created in
your Amazon Web Services account. You can optionally specify the maximum number of items to
receive in the response. If the total number of items in the list exceeds the maximum that
you specify, or the default maximum, the response is paginated. To get the next page of
items, send a subsequent request that specifies the NextMarker value from the current
response as the Marker value in the subsequent request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: Use this field when paginating results to indicate where to begin in your
list of response headers policies. The response includes response headers policies in the
list that occur after the marker. To get the next page of the list, set this field's value
to the value of NextMarker from the current page's response.
- `"MaxItems"`: The maximum number of response headers policies that you want to get in the
response.
- `"Type"`: A filter to get only the specified kind of response headers policies. Valid
values are: managed – Gets only the managed policies created by Amazon Web Services.
custom – Gets only the custom policies created in your Amazon Web Services account.
"""
function list_response_headers_policies2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_response_headers_policies2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/response-headers-policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_streaming_distributions2020_05_31()
list_streaming_distributions2020_05_31(params::Dict{String,<:Any})
List streaming distributions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Marker"`: The value that you provided for the Marker request parameter.
- `"MaxItems"`: The value that you provided for the MaxItems request parameter.
"""
function list_streaming_distributions2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_streaming_distributions2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/streaming-distribution",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource2020_05_31(resource)
list_tags_for_resource2020_05_31(resource, params::Dict{String,<:Any})
List tags for a CloudFront resource.
# Arguments
- `resource`: An ARN of a CloudFront resource.
"""
function list_tags_for_resource2020_05_31(
Resource; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"GET",
"/2020-05-31/tagging",
Dict{String,Any}("Resource" => Resource);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource2020_05_31(
Resource,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"GET",
"/2020-05-31/tagging",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Resource" => Resource), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
publish_function2020_05_31(if-_match, name)
publish_function2020_05_31(if-_match, name, params::Dict{String,<:Any})
Publishes a CloudFront function by copying the function code from the DEVELOPMENT stage to
LIVE. This automatically updates all cache behaviors that are using this function to use
the newly published copy in the LIVE stage. When a function is published to the LIVE stage,
you can attach the function to a distribution's cache behavior, using the function's Amazon
Resource Name (ARN). To publish a function, you must provide the function's name and
version (ETag value). To get these values, you can use ListFunctions and DescribeFunction.
# Arguments
- `if-_match`: The current version (ETag value) of the function that you are publishing,
which you can get using DescribeFunction.
- `name`: The name of the function that you are publishing.
"""
function publish_function2020_05_31(
If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/function/$(Name)/publish",
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function publish_function2020_05_31(
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/function/$(Name)/publish",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("headers" => Dict{String,Any}("If-Match" => If_Match)),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource2020_05_31(resource, tags)
tag_resource2020_05_31(resource, tags, params::Dict{String,<:Any})
Add tags to a CloudFront resource.
# Arguments
- `resource`: An ARN of a CloudFront resource.
- `tags`: A complex type that contains zero or more Tag elements.
"""
function tag_resource2020_05_31(
Resource, Tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/tagging?Operation=Tag",
Dict{String,Any}("Resource" => Resource, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource2020_05_31(
Resource,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/tagging?Operation=Tag",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Resource" => Resource, "Tags" => Tags), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_function2020_05_31(event_object, if-_match, name)
test_function2020_05_31(event_object, if-_match, name, params::Dict{String,<:Any})
Tests a CloudFront function. To test a function, you provide an event object that
represents an HTTP request or response that your CloudFront distribution could receive in
production. CloudFront runs the function, passing it the event object that you provided,
and returns the function's result (the modified event object) in the response. The response
also contains function logs and error messages, if any exist. For more information about
testing functions, see Testing functions in the Amazon CloudFront Developer Guide. To test
a function, you provide the function's name and version (ETag value) along with the event
object. To get the function's name and version, you can use ListFunctions and
DescribeFunction.
# Arguments
- `event_object`: The event object to test the function with. For more information about
the structure of the event object, see Testing functions in the Amazon CloudFront Developer
Guide.
- `if-_match`: The current version (ETag value) of the function that you are testing, which
you can get using DescribeFunction.
- `name`: The name of the function that you are testing.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Stage"`: The stage of the function that you are testing, either DEVELOPMENT or LIVE.
"""
function test_function2020_05_31(
EventObject, If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/function/$(Name)/test",
Dict{String,Any}(
"EventObject" => EventObject,
"headers" => Dict{String,Any}("If-Match" => If_Match),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_function2020_05_31(
EventObject,
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/function/$(Name)/test",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EventObject" => EventObject,
"headers" => Dict{String,Any}("If-Match" => If_Match),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource2020_05_31(resource, tag_keys)
untag_resource2020_05_31(resource, tag_keys, params::Dict{String,<:Any})
Remove tags from a CloudFront resource.
# Arguments
- `resource`: An ARN of a CloudFront resource.
- `tag_keys`: A complex type that contains zero or more Tag key elements.
"""
function untag_resource2020_05_31(
Resource, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"POST",
"/2020-05-31/tagging?Operation=Untag",
Dict{String,Any}("Resource" => Resource, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource2020_05_31(
Resource,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"POST",
"/2020-05-31/tagging?Operation=Untag",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Resource" => Resource, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_cache_policy2020_05_31(cache_policy_config, id)
update_cache_policy2020_05_31(cache_policy_config, id, params::Dict{String,<:Any})
Updates a cache policy configuration. When you update a cache policy configuration, all the
fields are updated with the values provided in the request. You cannot update some fields
independent of others. To update a cache policy configuration: Use GetCachePolicyConfig
to get the current configuration. Locally modify the fields in the cache policy
configuration that you want to update. Call UpdateCachePolicy by providing the entire
cache policy configuration, including the fields that you modified and those that you
didn't.
# Arguments
- `cache_policy_config`: A cache policy configuration.
- `id`: The unique identifier for the cache policy that you are updating. The identifier is
returned in a cache behavior's CachePolicyId field in the response to GetDistributionConfig.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the cache policy that you are updating. The version is
returned in the cache policy's ETag field in the response to GetCachePolicyConfig.
"""
function update_cache_policy2020_05_31(
CachePolicyConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/cache-policy/$(Id)",
Dict{String,Any}("CachePolicyConfig" => CachePolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_cache_policy2020_05_31(
CachePolicyConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/cache-policy/$(Id)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("CachePolicyConfig" => CachePolicyConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_cloud_front_origin_access_identity2020_05_31(cloud_front_origin_access_identity_config, id)
update_cloud_front_origin_access_identity2020_05_31(cloud_front_origin_access_identity_config, id, params::Dict{String,<:Any})
Update an origin access identity.
# Arguments
- `cloud_front_origin_access_identity_config`: The identity's configuration information.
- `id`: The identity's id.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the
identity's configuration. For example: E2QWRUHAPOMQZL.
"""
function update_cloud_front_origin_access_identity2020_05_31(
CloudFrontOriginAccessIdentityConfig,
Id;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)/config",
Dict{String,Any}(
"CloudFrontOriginAccessIdentityConfig" => CloudFrontOriginAccessIdentityConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_cloud_front_origin_access_identity2020_05_31(
CloudFrontOriginAccessIdentityConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/origin-access-identity/cloudfront/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CloudFrontOriginAccessIdentityConfig" =>
CloudFrontOriginAccessIdentityConfig,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_continuous_deployment_policy2020_05_31(continuous_deployment_policy_config, id)
update_continuous_deployment_policy2020_05_31(continuous_deployment_policy_config, id, params::Dict{String,<:Any})
Updates a continuous deployment policy. You can update a continuous deployment policy to
enable or disable it, to change the percentage of traffic that it sends to the staging
distribution, or to change the staging distribution that it sends traffic to. When you
update a continuous deployment policy configuration, all the fields are updated with the
values that are provided in the request. You cannot update some fields independent of
others. To update a continuous deployment policy configuration: Use
GetContinuousDeploymentPolicyConfig to get the current configuration. Locally modify the
fields in the continuous deployment policy configuration that you want to update. Use
UpdateContinuousDeploymentPolicy, providing the entire continuous deployment policy
configuration, including the fields that you modified and those that you didn't.
# Arguments
- `continuous_deployment_policy_config`: The continuous deployment policy configuration.
- `id`: The identifier of the continuous deployment policy that you are updating.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The current version (ETag value) of the continuous deployment policy that
you are updating.
"""
function update_continuous_deployment_policy2020_05_31(
ContinuousDeploymentPolicyConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/continuous-deployment-policy/$(Id)",
Dict{String,Any}(
"ContinuousDeploymentPolicyConfig" => ContinuousDeploymentPolicyConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_continuous_deployment_policy2020_05_31(
ContinuousDeploymentPolicyConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/continuous-deployment-policy/$(Id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ContinuousDeploymentPolicyConfig" => ContinuousDeploymentPolicyConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_distribution2020_05_31(distribution_config, id)
update_distribution2020_05_31(distribution_config, id, params::Dict{String,<:Any})
Updates the configuration for a CloudFront distribution. The update process includes
getting the current distribution configuration, updating it to make your changes, and then
submitting an UpdateDistribution request to make the updates. To update a web distribution
using the CloudFront API Use GetDistributionConfig to get the current configuration,
including the version identifier (ETag). Update the distribution configuration that was
returned in the response. Note the following important requirements and restrictions: You
must rename the ETag field to IfMatch, leaving the value unchanged. (Set the value of
IfMatch to the value of ETag, then remove the ETag field.) You can't change the value of
CallerReference. Submit an UpdateDistribution request, providing the distribution
configuration. The new configuration replaces the existing configuration. The values that
you specify in an UpdateDistribution request are not merged into your existing
configuration. Make sure to include all fields: the ones that you modified and also the
ones that you didn't.
# Arguments
- `distribution_config`: The distribution's configuration information.
- `id`: The distribution's id.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the
distribution's configuration. For example: E2QWRUHAPOMQZL.
"""
function update_distribution2020_05_31(
DistributionConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(Id)/config",
Dict{String,Any}("DistributionConfig" => DistributionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_distribution2020_05_31(
DistributionConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("DistributionConfig" => DistributionConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_distribution_with_staging_config2020_05_31(id)
update_distribution_with_staging_config2020_05_31(id, params::Dict{String,<:Any})
Copies the staging distribution's configuration to its corresponding primary distribution.
The primary distribution retains its Aliases (also known as alternate domain names or
CNAMEs) and ContinuousDeploymentPolicyId value, but otherwise its configuration is
overwritten to match the staging distribution. You can use this operation in a continuous
deployment workflow after you have tested configuration changes on the staging
distribution. After using a continuous deployment policy to move a portion of your domain
name's traffic to the staging distribution and verifying that it works as intended, you can
use this operation to copy the staging distribution's configuration to the primary
distribution. This action will disable the continuous deployment policy and move your
domain's traffic back to the primary distribution. This API operation requires the
following IAM permissions: GetDistribution UpdateDistribution
# Arguments
- `id`: The identifier of the primary distribution to which you are copying a staging
distribution's configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The current versions (ETag values) of both primary and staging
distributions. Provide these in the following format: <primary ETag>, <staging
ETag>
- `"StagingDistributionId"`: The identifier of the staging distribution whose configuration
you are copying to the primary distribution.
"""
function update_distribution_with_staging_config2020_05_31(
Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(Id)/promote-staging-config";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_distribution_with_staging_config2020_05_31(
Id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/distribution/$(Id)/promote-staging-config",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_field_level_encryption_config2020_05_31(field_level_encryption_config, id)
update_field_level_encryption_config2020_05_31(field_level_encryption_config, id, params::Dict{String,<:Any})
Update a field-level encryption configuration.
# Arguments
- `field_level_encryption_config`: Request to update a field-level encryption configuration.
- `id`: The ID of the configuration you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the
configuration identity to update. For example: E2QWRUHAPOMQZL.
"""
function update_field_level_encryption_config2020_05_31(
FieldLevelEncryptionConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/field-level-encryption/$(Id)/config",
Dict{String,Any}("FieldLevelEncryptionConfig" => FieldLevelEncryptionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_field_level_encryption_config2020_05_31(
FieldLevelEncryptionConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/field-level-encryption/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FieldLevelEncryptionConfig" => FieldLevelEncryptionConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_field_level_encryption_profile2020_05_31(field_level_encryption_profile_config, id)
update_field_level_encryption_profile2020_05_31(field_level_encryption_profile_config, id, params::Dict{String,<:Any})
Update a field-level encryption profile.
# Arguments
- `field_level_encryption_profile_config`: Request to update a field-level encryption
profile.
- `id`: The ID of the field-level encryption profile request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the profile
identity to update. For example: E2QWRUHAPOMQZL.
"""
function update_field_level_encryption_profile2020_05_31(
FieldLevelEncryptionProfileConfig, Id; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/field-level-encryption-profile/$(Id)/config",
Dict{String,Any}(
"FieldLevelEncryptionProfileConfig" => FieldLevelEncryptionProfileConfig
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_field_level_encryption_profile2020_05_31(
FieldLevelEncryptionProfileConfig,
Id,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/field-level-encryption-profile/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FieldLevelEncryptionProfileConfig" => FieldLevelEncryptionProfileConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_function2020_05_31(function_code, function_config, if-_match, name)
update_function2020_05_31(function_code, function_config, if-_match, name, params::Dict{String,<:Any})
Updates a CloudFront function. You can update a function's code or the comment that
describes the function. You cannot update a function's name. To update a function, you
provide the function's name and version (ETag value) along with the updated function code.
To get the name and version, you can use ListFunctions and DescribeFunction.
# Arguments
- `function_code`: The function code. For more information about writing a CloudFront
function, see Writing function code for CloudFront Functions in the Amazon CloudFront
Developer Guide.
- `function_config`: Configuration information about the function.
- `if-_match`: The current version (ETag value) of the function that you are updating,
which you can get using DescribeFunction.
- `name`: The name of the function that you are updating.
"""
function update_function2020_05_31(
FunctionCode,
FunctionConfig,
If_Match,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/function/$(Name)",
Dict{String,Any}(
"FunctionCode" => FunctionCode,
"FunctionConfig" => FunctionConfig,
"headers" => Dict{String,Any}("If-Match" => If_Match),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_function2020_05_31(
FunctionCode,
FunctionConfig,
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/function/$(Name)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FunctionCode" => FunctionCode,
"FunctionConfig" => FunctionConfig,
"headers" => Dict{String,Any}("If-Match" => If_Match),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_key_group2020_05_31(id, key_group_config)
update_key_group2020_05_31(id, key_group_config, params::Dict{String,<:Any})
Updates a key group. When you update a key group, all the fields are updated with the
values provided in the request. You cannot update some fields independent of others. To
update a key group: Get the current key group with GetKeyGroup or GetKeyGroupConfig.
Locally modify the fields in the key group that you want to update. For example, add or
remove public key IDs. Call UpdateKeyGroup with the entire key group object, including
the fields that you modified and those that you didn't.
# Arguments
- `id`: The identifier of the key group that you are updating.
- `key_group_config`: The key group configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the key group that you are updating. The version is the key
group's ETag value.
"""
function update_key_group2020_05_31(
Id, KeyGroupConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/key-group/$(Id)",
Dict{String,Any}("KeyGroupConfig" => KeyGroupConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_key_group2020_05_31(
Id,
KeyGroupConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/key-group/$(Id)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("KeyGroupConfig" => KeyGroupConfig), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_key_value_store2020_05_31(comment, if-_match, name)
update_key_value_store2020_05_31(comment, if-_match, name, params::Dict{String,<:Any})
Specifies the key value store to update.
# Arguments
- `comment`: The comment of the key value store to update.
- `if-_match`: The key value store to update, if a match occurs.
- `name`: The name of the key value store to update.
"""
function update_key_value_store2020_05_31(
Comment, If_Match, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/key-value-store/$(Name)",
Dict{String,Any}(
"Comment" => Comment, "headers" => Dict{String,Any}("If-Match" => If_Match)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_key_value_store2020_05_31(
Comment,
If_Match,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/key-value-store/$(Name)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Comment" => Comment,
"headers" => Dict{String,Any}("If-Match" => If_Match),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_origin_access_control2020_05_31(id, origin_access_control_config)
update_origin_access_control2020_05_31(id, origin_access_control_config, params::Dict{String,<:Any})
Updates a CloudFront origin access control.
# Arguments
- `id`: The unique identifier of the origin access control that you are updating.
- `origin_access_control_config`: An origin access control.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The current version (ETag value) of the origin access control that you are
updating.
"""
function update_origin_access_control2020_05_31(
Id, OriginAccessControlConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/origin-access-control/$(Id)/config",
Dict{String,Any}("OriginAccessControlConfig" => OriginAccessControlConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_origin_access_control2020_05_31(
Id,
OriginAccessControlConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/origin-access-control/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("OriginAccessControlConfig" => OriginAccessControlConfig),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_origin_request_policy2020_05_31(id, origin_request_policy_config)
update_origin_request_policy2020_05_31(id, origin_request_policy_config, params::Dict{String,<:Any})
Updates an origin request policy configuration. When you update an origin request policy
configuration, all the fields are updated with the values provided in the request. You
cannot update some fields independent of others. To update an origin request policy
configuration: Use GetOriginRequestPolicyConfig to get the current configuration.
Locally modify the fields in the origin request policy configuration that you want to
update. Call UpdateOriginRequestPolicy by providing the entire origin request policy
configuration, including the fields that you modified and those that you didn't.
# Arguments
- `id`: The unique identifier for the origin request policy that you are updating. The
identifier is returned in a cache behavior's OriginRequestPolicyId field in the response to
GetDistributionConfig.
- `origin_request_policy_config`: An origin request policy configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the origin request policy that you are updating. The version
is returned in the origin request policy's ETag field in the response to
GetOriginRequestPolicyConfig.
"""
function update_origin_request_policy2020_05_31(
Id, OriginRequestPolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/origin-request-policy/$(Id)",
Dict{String,Any}("OriginRequestPolicyConfig" => OriginRequestPolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_origin_request_policy2020_05_31(
Id,
OriginRequestPolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/origin-request-policy/$(Id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("OriginRequestPolicyConfig" => OriginRequestPolicyConfig),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_public_key2020_05_31(id, public_key_config)
update_public_key2020_05_31(id, public_key_config, params::Dict{String,<:Any})
Update public key information. Note that the only value you can change is the comment.
# Arguments
- `id`: The identifier of the public key that you are updating.
- `public_key_config`: A public key configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the public
key to update. For example: E2QWRUHAPOMQZL.
"""
function update_public_key2020_05_31(
Id, PublicKeyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/public-key/$(Id)/config",
Dict{String,Any}("PublicKeyConfig" => PublicKeyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_public_key2020_05_31(
Id,
PublicKeyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/public-key/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("PublicKeyConfig" => PublicKeyConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_realtime_log_config2020_05_31()
update_realtime_log_config2020_05_31(params::Dict{String,<:Any})
Updates a real-time log configuration. When you update a real-time log configuration, all
the parameters are updated with the values provided in the request. You cannot update some
parameters independent of others. To update a real-time log configuration: Call
GetRealtimeLogConfig to get the current real-time log configuration. Locally modify the
parameters in the real-time log configuration that you want to update. Call this API
(UpdateRealtimeLogConfig) by providing the entire real-time log configuration, including
the parameters that you modified and those that you didn't. You cannot update a real-time
log configuration's Name or ARN.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ARN"`: The Amazon Resource Name (ARN) for this real-time log configuration.
- `"EndPoints"`: Contains information about the Amazon Kinesis data stream where you are
sending real-time log data.
- `"Fields"`: A list of fields to include in each real-time log record. For more
information about fields, see Real-time log configuration fields in the Amazon CloudFront
Developer Guide.
- `"Name"`: The name for this real-time log configuration.
- `"SamplingRate"`: The sampling rate for this real-time log configuration. The sampling
rate determines the percentage of viewer requests that are represented in the real-time log
data. You must provide an integer between 1 and 100, inclusive.
"""
function update_realtime_log_config2020_05_31(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/realtime-log-config/";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_realtime_log_config2020_05_31(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/realtime-log-config/",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_response_headers_policy2020_05_31(id, response_headers_policy_config)
update_response_headers_policy2020_05_31(id, response_headers_policy_config, params::Dict{String,<:Any})
Updates a response headers policy. When you update a response headers policy, the entire
policy is replaced. You cannot update some policy fields independent of others. To update a
response headers policy configuration: Use GetResponseHeadersPolicyConfig to get the
current policy's configuration. Modify the fields in the response headers policy
configuration that you want to update. Call UpdateResponseHeadersPolicy, providing the
entire response headers policy configuration, including the fields that you modified and
those that you didn't.
# Arguments
- `id`: The identifier for the response headers policy that you are updating.
- `response_headers_policy_config`: A response headers policy configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The version of the response headers policy that you are updating. The
version is returned in the cache policy's ETag field in the response to
GetResponseHeadersPolicyConfig.
"""
function update_response_headers_policy2020_05_31(
Id, ResponseHeadersPolicyConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/response-headers-policy/$(Id)",
Dict{String,Any}("ResponseHeadersPolicyConfig" => ResponseHeadersPolicyConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_response_headers_policy2020_05_31(
Id,
ResponseHeadersPolicyConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/response-headers-policy/$(Id)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResponseHeadersPolicyConfig" => ResponseHeadersPolicyConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_streaming_distribution2020_05_31(id, streaming_distribution_config)
update_streaming_distribution2020_05_31(id, streaming_distribution_config, params::Dict{String,<:Any})
Update a streaming distribution.
# Arguments
- `id`: The streaming distribution's id.
- `streaming_distribution_config`: The streaming distribution's configuration information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"If-Match"`: The value of the ETag header that you received when retrieving the
streaming distribution's configuration. For example: E2QWRUHAPOMQZL.
"""
function update_streaming_distribution2020_05_31(
Id, StreamingDistributionConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudfront(
"PUT",
"/2020-05-31/streaming-distribution/$(Id)/config",
Dict{String,Any}("StreamingDistributionConfig" => StreamingDistributionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_streaming_distribution2020_05_31(
Id,
StreamingDistributionConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudfront(
"PUT",
"/2020-05-31/streaming-distribution/$(Id)/config",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"StreamingDistributionConfig" => StreamingDistributionConfig
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 29197 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudhsm
using AWS.Compat
using AWS.UUIDs
"""
add_tags_to_resource(resource_arn, tag_list)
add_tags_to_resource(resource_arn, tag_list, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Adds or overwrites one or
more tags for the specified AWS CloudHSM resource. Each tag consists of a key and a value.
Tag keys must be unique to each resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the AWS CloudHSM resource to tag.
- `tag_list`: One or more tags.
"""
function add_tags_to_resource(
ResourceArn, TagList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"AddTagsToResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagList" => TagList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_tags_to_resource(
ResourceArn,
TagList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"AddTagsToResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagList" => TagList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_hapg(label)
create_hapg(label, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Creates a
high-availability partition group. A high-availability partition group is a group of
partitions that spans multiple physical HSMs.
# Arguments
- `label`: The label of the new high-availability partition group.
"""
function create_hapg(Label; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"CreateHapg",
Dict{String,Any}("Label" => Label);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_hapg(
Label, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"CreateHapg",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Label" => Label), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_hsm(iam_role_arn, ssh_key, subnet_id, subscription_type)
create_hsm(iam_role_arn, ssh_key, subnet_id, subscription_type, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Creates an uninitialized
HSM instance. There is an upfront fee charged for each HSM instance that you create with
the CreateHsm operation. If you accidentally provision an HSM and want to request a refund,
delete the instance using the DeleteHsm operation, go to the AWS Support Center, create a
new case, and select Account and Billing Support. It can take up to 20 minutes to create
and provision an HSM. You can monitor the status of the HSM with the DescribeHsm operation.
The HSM is ready to be initialized when the status changes to RUNNING.
# Arguments
- `iam_role_arn`: The ARN of an IAM role to enable the AWS CloudHSM service to allocate an
ENI on your behalf.
- `ssh_key`: The SSH public key to install on the HSM.
- `subnet_id`: The identifier of the subnet in your VPC in which to place the HSM.
- `subscription_type`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientToken"`: A user-defined token to ensure idempotence. Subsequent calls to this
operation with the same token will be ignored.
- `"EniIp"`: The IP address to assign to the HSM's ENI. If an IP address is not specified,
an IP address will be randomly chosen from the CIDR range of the subnet.
- `"ExternalId"`: The external ID from IamRoleArn, if present.
- `"SyslogIp"`: The IP address for the syslog monitoring server. The AWS CloudHSM service
only supports one syslog monitoring server.
"""
function create_hsm(
IamRoleArn,
SshKey,
SubnetId,
SubscriptionType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"CreateHsm",
Dict{String,Any}(
"IamRoleArn" => IamRoleArn,
"SshKey" => SshKey,
"SubnetId" => SubnetId,
"SubscriptionType" => SubscriptionType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_hsm(
IamRoleArn,
SshKey,
SubnetId,
SubscriptionType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"CreateHsm",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"IamRoleArn" => IamRoleArn,
"SshKey" => SshKey,
"SubnetId" => SubnetId,
"SubscriptionType" => SubscriptionType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_luna_client(certificate)
create_luna_client(certificate, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Creates an HSM client.
# Arguments
- `certificate`: The contents of a Base64-Encoded X.509 v3 certificate to be installed on
the HSMs used by this client.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Label"`: The label for the client.
"""
function create_luna_client(Certificate; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"CreateLunaClient",
Dict{String,Any}("Certificate" => Certificate);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_luna_client(
Certificate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"CreateLunaClient",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Certificate" => Certificate), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_hapg(hapg_arn)
delete_hapg(hapg_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Deletes a
high-availability partition group.
# Arguments
- `hapg_arn`: The ARN of the high-availability partition group to delete.
"""
function delete_hapg(HapgArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"DeleteHapg",
Dict{String,Any}("HapgArn" => HapgArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_hapg(
HapgArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"DeleteHapg",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HapgArn" => HapgArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_hsm(hsm_arn)
delete_hsm(hsm_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Deletes an HSM. After
completion, this operation cannot be undone and your key material cannot be recovered.
# Arguments
- `hsm_arn`: The ARN of the HSM to delete.
"""
function delete_hsm(HsmArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"DeleteHsm",
Dict{String,Any}("HsmArn" => HsmArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_hsm(
HsmArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"DeleteHsm",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HsmArn" => HsmArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_luna_client(client_arn)
delete_luna_client(client_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Deletes a client.
# Arguments
- `client_arn`: The ARN of the client to delete.
"""
function delete_luna_client(ClientArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"DeleteLunaClient",
Dict{String,Any}("ClientArn" => ClientArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_luna_client(
ClientArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"DeleteLunaClient",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ClientArn" => ClientArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_hapg(hapg_arn)
describe_hapg(hapg_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Retrieves information
about a high-availability partition group.
# Arguments
- `hapg_arn`: The ARN of the high-availability partition group to describe.
"""
function describe_hapg(HapgArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"DescribeHapg",
Dict{String,Any}("HapgArn" => HapgArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_hapg(
HapgArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"DescribeHapg",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HapgArn" => HapgArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_hsm()
describe_hsm(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Retrieves information
about an HSM. You can identify the HSM by its ARN or its serial number.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"HsmArn"`: The ARN of the HSM. Either the HsmArn or the SerialNumber parameter must be
specified.
- `"HsmSerialNumber"`: The serial number of the HSM. Either the HsmArn or the
HsmSerialNumber parameter must be specified.
"""
function describe_hsm(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm("DescribeHsm"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function describe_hsm(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"DescribeHsm", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_luna_client()
describe_luna_client(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Retrieves information
about an HSM client.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CertificateFingerprint"`: The certificate fingerprint.
- `"ClientArn"`: The ARN of the client.
"""
function describe_luna_client(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"DescribeLunaClient"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_luna_client(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"DescribeLunaClient", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_config(client_arn, client_version, hapg_list)
get_config(client_arn, client_version, hapg_list, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Gets the configuration
files necessary to connect to all high availability partition groups the client is
associated with.
# Arguments
- `client_arn`: The ARN of the client.
- `client_version`: The client version.
- `hapg_list`: A list of ARNs that identify the high-availability partition groups that are
associated with the client.
"""
function get_config(
ClientArn, ClientVersion, HapgList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"GetConfig",
Dict{String,Any}(
"ClientArn" => ClientArn,
"ClientVersion" => ClientVersion,
"HapgList" => HapgList,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_config(
ClientArn,
ClientVersion,
HapgList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"GetConfig",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClientArn" => ClientArn,
"ClientVersion" => ClientVersion,
"HapgList" => HapgList,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_available_zones()
list_available_zones(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Lists the Availability
Zones that have available AWS CloudHSM capacity.
"""
function list_available_zones(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"ListAvailableZones"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_available_zones(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ListAvailableZones", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_hapgs()
list_hapgs(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Lists the
high-availability partition groups for the account. This operation supports pagination with
the use of the NextToken member. If more results are available, the NextToken member of the
response contains a token that you pass in the next call to ListHapgs to retrieve the next
set of items.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The NextToken value from a previous call to ListHapgs. Pass null if this
is the first call.
"""
function list_hapgs(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm("ListHapgs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_hapgs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ListHapgs", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_hsms()
list_hsms(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Retrieves the identifiers
of all of the HSMs provisioned for the current customer. This operation supports pagination
with the use of the NextToken member. If more results are available, the NextToken member
of the response contains a token that you pass in the next call to ListHsms to retrieve the
next set of items.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The NextToken value from a previous call to ListHsms. Pass null if this is
the first call.
"""
function list_hsms(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm("ListHsms"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_hsms(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ListHsms", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_luna_clients()
list_luna_clients(params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Lists all of the clients.
This operation supports pagination with the use of the NextToken member. If more results
are available, the NextToken member of the response contains a token that you pass in the
next call to ListLunaClients to retrieve the next set of items.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The NextToken value from a previous call to ListLunaClients. Pass null if
this is the first call.
"""
function list_luna_clients(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"ListLunaClients"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_luna_clients(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ListLunaClients", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Returns a list of all tags
for the specified AWS CloudHSM resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the AWS CloudHSM resource.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
modify_hapg(hapg_arn)
modify_hapg(hapg_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Modifies an existing
high-availability partition group.
# Arguments
- `hapg_arn`: The ARN of the high-availability partition group to modify.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Label"`: The new label for the high-availability partition group.
- `"PartitionSerialList"`: The list of partition serial numbers to make members of the
high-availability partition group.
"""
function modify_hapg(HapgArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"ModifyHapg",
Dict{String,Any}("HapgArn" => HapgArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function modify_hapg(
HapgArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ModifyHapg",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HapgArn" => HapgArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
modify_hsm(hsm_arn)
modify_hsm(hsm_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Modifies an HSM. This
operation can result in the HSM being offline for up to 15 minutes while the AWS CloudHSM
service is reconfigured. If you are modifying a production HSM, you should ensure that your
AWS CloudHSM service is configured for high availability, and consider executing this
operation during a maintenance window.
# Arguments
- `hsm_arn`: The ARN of the HSM to modify.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EniIp"`: The new IP address for the elastic network interface (ENI) attached to the
HSM. If the HSM is moved to a different subnet, and an IP address is not specified, an IP
address will be randomly chosen from the CIDR range of the new subnet.
- `"ExternalId"`: The new external ID.
- `"IamRoleArn"`: The new IAM role ARN.
- `"SubnetId"`: The new identifier of the subnet that the HSM is in. The new subnet must be
in the same Availability Zone as the current subnet.
- `"SyslogIp"`: The new IP address for the syslog monitoring server. The AWS CloudHSM
service only supports one syslog monitoring server.
"""
function modify_hsm(HsmArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm(
"ModifyHsm",
Dict{String,Any}("HsmArn" => HsmArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function modify_hsm(
HsmArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ModifyHsm",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HsmArn" => HsmArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
modify_luna_client(certificate, client_arn)
modify_luna_client(certificate, client_arn, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Modifies the certificate
used by the client. This action can potentially start a workflow to install the new
certificate on the client's HSMs.
# Arguments
- `certificate`: The new certificate for the client.
- `client_arn`: The ARN of the client.
"""
function modify_luna_client(
Certificate, ClientArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"ModifyLunaClient",
Dict{String,Any}("Certificate" => Certificate, "ClientArn" => ClientArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function modify_luna_client(
Certificate,
ClientArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"ModifyLunaClient",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Certificate" => Certificate, "ClientArn" => ClientArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_tags_from_resource(resource_arn, tag_key_list)
remove_tags_from_resource(resource_arn, tag_key_list, params::Dict{String,<:Any})
This is documentation for AWS CloudHSM Classic. For more information, see AWS CloudHSM
Classic FAQs, the AWS CloudHSM Classic User Guide, and the AWS CloudHSM Classic API
Reference. For information about the current version of AWS CloudHSM, see AWS CloudHSM,
the AWS CloudHSM User Guide, and the AWS CloudHSM API Reference. Removes one or more tags
from the specified AWS CloudHSM resource. To remove a tag, specify only the tag key to
remove (not the value). To overwrite the value for an existing tag, use AddTagsToResource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the AWS CloudHSM resource.
- `tag_key_list`: The tag key or keys to remove. Specify only the tag key to remove (not
the value). To overwrite the value for an existing tag, use AddTagsToResource.
"""
function remove_tags_from_resource(
ResourceArn, TagKeyList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm(
"RemoveTagsFromResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeyList" => TagKeyList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_tags_from_resource(
ResourceArn,
TagKeyList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm(
"RemoveTagsFromResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeyList" => TagKeyList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 23366 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudhsm_v2
using AWS.Compat
using AWS.UUIDs
"""
copy_backup_to_region(backup_id, destination_region)
copy_backup_to_region(backup_id, destination_region, params::Dict{String,<:Any})
Copy an AWS CloudHSM cluster backup to a different region.
# Arguments
- `backup_id`: The ID of the backup that will be copied to the destination region.
- `destination_region`: The AWS region that will contain your copied CloudHSM cluster
backup.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"TagList"`: Tags to apply to the destination backup during creation. If you specify
tags, only these tags will be applied to the destination backup. If you do not specify
tags, the service copies tags from the source backup to the destination backup.
"""
function copy_backup_to_region(
BackupId, DestinationRegion; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"CopyBackupToRegion",
Dict{String,Any}("BackupId" => BackupId, "DestinationRegion" => DestinationRegion);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function copy_backup_to_region(
BackupId,
DestinationRegion,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"CopyBackupToRegion",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BackupId" => BackupId, "DestinationRegion" => DestinationRegion
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_cluster(hsm_type, subnet_ids)
create_cluster(hsm_type, subnet_ids, params::Dict{String,<:Any})
Creates a new AWS CloudHSM cluster.
# Arguments
- `hsm_type`: The type of HSM to use in the cluster. The allowed values are hsm1.medium and
hsm2m.medium.
- `subnet_ids`: The identifiers (IDs) of the subnets where you are creating the cluster.
You must specify at least one subnet. If you specify multiple subnets, they must meet the
following criteria: All subnets must be in the same virtual private cloud (VPC). You
can specify only one subnet per Availability Zone.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BackupRetentionPolicy"`: A policy that defines how the service retains backups.
- `"Mode"`: The mode to use in the cluster. The allowed values are FIPS and NON_FIPS.
- `"SourceBackupId"`: The identifier (ID) of the cluster backup to restore. Use this value
to restore the cluster from a backup instead of creating a new cluster. To find the backup
ID, use DescribeBackups.
- `"TagList"`: Tags to apply to the CloudHSM cluster during creation.
"""
function create_cluster(
HsmType, SubnetIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"CreateCluster",
Dict{String,Any}("HsmType" => HsmType, "SubnetIds" => SubnetIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_cluster(
HsmType,
SubnetIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"CreateCluster",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("HsmType" => HsmType, "SubnetIds" => SubnetIds),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_hsm(availability_zone, cluster_id)
create_hsm(availability_zone, cluster_id, params::Dict{String,<:Any})
Creates a new hardware security module (HSM) in the specified AWS CloudHSM cluster.
# Arguments
- `availability_zone`: The Availability Zone where you are creating the HSM. To find the
cluster's Availability Zones, use DescribeClusters.
- `cluster_id`: The identifier (ID) of the HSM's cluster. To find the cluster ID, use
DescribeClusters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IpAddress"`: The HSM's IP address. If you specify an IP address, use an available
address from the subnet that maps to the Availability Zone where you are creating the HSM.
If you don't specify an IP address, one is chosen for you from that subnet.
"""
function create_hsm(
AvailabilityZone, ClusterId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"CreateHsm",
Dict{String,Any}("AvailabilityZone" => AvailabilityZone, "ClusterId" => ClusterId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_hsm(
AvailabilityZone,
ClusterId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"CreateHsm",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AvailabilityZone" => AvailabilityZone, "ClusterId" => ClusterId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_backup(backup_id)
delete_backup(backup_id, params::Dict{String,<:Any})
Deletes a specified AWS CloudHSM backup. A backup can be restored up to 7 days after the
DeleteBackup request is made. For more information on restoring a backup, see RestoreBackup.
# Arguments
- `backup_id`: The ID of the backup to be deleted. To find the ID of a backup, use the
DescribeBackups operation.
"""
function delete_backup(BackupId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"DeleteBackup",
Dict{String,Any}("BackupId" => BackupId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_backup(
BackupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"DeleteBackup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("BackupId" => BackupId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_cluster(cluster_id)
delete_cluster(cluster_id, params::Dict{String,<:Any})
Deletes the specified AWS CloudHSM cluster. Before you can delete a cluster, you must
delete all HSMs in the cluster. To see if the cluster contains any HSMs, use
DescribeClusters. To delete an HSM, use DeleteHsm.
# Arguments
- `cluster_id`: The identifier (ID) of the cluster that you are deleting. To find the
cluster ID, use DescribeClusters.
"""
function delete_cluster(ClusterId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"DeleteCluster",
Dict{String,Any}("ClusterId" => ClusterId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_cluster(
ClusterId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"DeleteCluster",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ClusterId" => ClusterId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_hsm(cluster_id)
delete_hsm(cluster_id, params::Dict{String,<:Any})
Deletes the specified HSM. To specify an HSM, you can use its identifier (ID), the IP
address of the HSM's elastic network interface (ENI), or the ID of the HSM's ENI. You need
to specify only one of these values. To find these values, use DescribeClusters.
# Arguments
- `cluster_id`: The identifier (ID) of the cluster that contains the HSM that you are
deleting.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EniId"`: The identifier (ID) of the elastic network interface (ENI) of the HSM that you
are deleting.
- `"EniIp"`: The IP address of the elastic network interface (ENI) of the HSM that you are
deleting.
- `"HsmId"`: The identifier (ID) of the HSM that you are deleting.
"""
function delete_hsm(ClusterId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"DeleteHsm",
Dict{String,Any}("ClusterId" => ClusterId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_hsm(
ClusterId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"DeleteHsm",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ClusterId" => ClusterId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_backups()
describe_backups(params::Dict{String,<:Any})
Gets information about backups of AWS CloudHSM clusters. This is a paginated operation,
which means that each response might contain only a subset of all the backups. When the
response contains only a subset of backups, it includes a NextToken value. Use this value
in a subsequent DescribeBackups request to get more backups. When you receive a response
with no NextToken (or an empty or null value), that means there are no more backups to get.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: One or more filters to limit the items returned in the response. Use the
backupIds filter to return only the specified backups. Specify backups by their backup
identifier (ID). Use the sourceBackupIds filter to return only the backups created from a
source backup. The sourceBackupID of a source backup is returned by the CopyBackupToRegion
operation. Use the clusterIds filter to return only the backups for the specified clusters.
Specify clusters by their cluster identifier (ID). Use the states filter to return only
backups that match the specified state. Use the neverExpires filter to return backups
filtered by the value in the neverExpires parameter. True returns all backups exempt from
the backup retention policy. False returns all backups with a backup retention policy
defined at the cluster.
- `"MaxResults"`: The maximum number of backups to return in the response. When there are
more backups than the number you specify, the response contains a NextToken value.
- `"NextToken"`: The NextToken value that you received in the previous response. Use this
value to get more backups.
- `"SortAscending"`: Designates whether or not to sort the return backups by ascending
chronological order of generation.
"""
function describe_backups(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"DescribeBackups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_backups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"DescribeBackups", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_clusters()
describe_clusters(params::Dict{String,<:Any})
Gets information about AWS CloudHSM clusters. This is a paginated operation, which means
that each response might contain only a subset of all the clusters. When the response
contains only a subset of clusters, it includes a NextToken value. Use this value in a
subsequent DescribeClusters request to get more clusters. When you receive a response with
no NextToken (or an empty or null value), that means there are no more clusters to get.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: One or more filters to limit the items returned in the response. Use the
clusterIds filter to return only the specified clusters. Specify clusters by their cluster
identifier (ID). Use the vpcIds filter to return only the clusters in the specified virtual
private clouds (VPCs). Specify VPCs by their VPC identifier (ID). Use the states filter to
return only clusters that match the specified state.
- `"MaxResults"`: The maximum number of clusters to return in the response. When there are
more clusters than the number you specify, the response contains a NextToken value.
- `"NextToken"`: The NextToken value that you received in the previous response. Use this
value to get more clusters.
"""
function describe_clusters(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"DescribeClusters"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_clusters(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"DescribeClusters", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
initialize_cluster(cluster_id, signed_cert, trust_anchor)
initialize_cluster(cluster_id, signed_cert, trust_anchor, params::Dict{String,<:Any})
Claims an AWS CloudHSM cluster by submitting the cluster certificate issued by your issuing
certificate authority (CA) and the CA's root certificate. Before you can claim a cluster,
you must sign the cluster's certificate signing request (CSR) with your issuing CA. To get
the cluster's CSR, use DescribeClusters.
# Arguments
- `cluster_id`: The identifier (ID) of the cluster that you are claiming. To find the
cluster ID, use DescribeClusters.
- `signed_cert`: The cluster certificate issued (signed) by your issuing certificate
authority (CA). The certificate must be in PEM format and can contain a maximum of 5000
characters.
- `trust_anchor`: The issuing certificate of the issuing certificate authority (CA) that
issued (signed) the cluster certificate. You must use a self-signed certificate. The
certificate used to sign the HSM CSR must be directly available, and thus must be the root
certificate. The certificate must be in PEM format and can contain a maximum of 5000
characters.
"""
function initialize_cluster(
ClusterId, SignedCert, TrustAnchor; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"InitializeCluster",
Dict{String,Any}(
"ClusterId" => ClusterId,
"SignedCert" => SignedCert,
"TrustAnchor" => TrustAnchor,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function initialize_cluster(
ClusterId,
SignedCert,
TrustAnchor,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"InitializeCluster",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ClusterId" => ClusterId,
"SignedCert" => SignedCert,
"TrustAnchor" => TrustAnchor,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags(resource_id)
list_tags(resource_id, params::Dict{String,<:Any})
Gets a list of tags for the specified AWS CloudHSM cluster. This is a paginated operation,
which means that each response might contain only a subset of all the tags. When the
response contains only a subset of tags, it includes a NextToken value. Use this value in a
subsequent ListTags request to get more tags. When you receive a response with no NextToken
(or an empty or null value), that means there are no more tags to get.
# Arguments
- `resource_id`: The cluster identifier (ID) for the cluster whose tags you are getting. To
find the cluster ID, use DescribeClusters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of tags to return in the response. When there are more
tags than the number you specify, the response contains a NextToken value.
- `"NextToken"`: The NextToken value that you received in the previous response. Use this
value to get more tags.
"""
function list_tags(ResourceId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"ListTags",
Dict{String,Any}("ResourceId" => ResourceId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags(
ResourceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"ListTags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceId" => ResourceId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
modify_backup_attributes(backup_id, never_expires)
modify_backup_attributes(backup_id, never_expires, params::Dict{String,<:Any})
Modifies attributes for AWS CloudHSM backup.
# Arguments
- `backup_id`: The identifier (ID) of the backup to modify. To find the ID of a backup, use
the DescribeBackups operation.
- `never_expires`: Specifies whether the service should exempt a backup from the retention
policy for the cluster. True exempts a backup from the retention policy. False means the
service applies the backup retention policy defined at the cluster.
"""
function modify_backup_attributes(
BackupId, NeverExpires; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"ModifyBackupAttributes",
Dict{String,Any}("BackupId" => BackupId, "NeverExpires" => NeverExpires);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function modify_backup_attributes(
BackupId,
NeverExpires,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"ModifyBackupAttributes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("BackupId" => BackupId, "NeverExpires" => NeverExpires),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
modify_cluster(backup_retention_policy, cluster_id)
modify_cluster(backup_retention_policy, cluster_id, params::Dict{String,<:Any})
Modifies AWS CloudHSM cluster.
# Arguments
- `backup_retention_policy`: A policy that defines how the service retains backups.
- `cluster_id`: The identifier (ID) of the cluster that you want to modify. To find the
cluster ID, use DescribeClusters.
"""
function modify_cluster(
BackupRetentionPolicy, ClusterId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"ModifyCluster",
Dict{String,Any}(
"BackupRetentionPolicy" => BackupRetentionPolicy, "ClusterId" => ClusterId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function modify_cluster(
BackupRetentionPolicy,
ClusterId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"ModifyCluster",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"BackupRetentionPolicy" => BackupRetentionPolicy,
"ClusterId" => ClusterId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
restore_backup(backup_id)
restore_backup(backup_id, params::Dict{String,<:Any})
Restores a specified AWS CloudHSM backup that is in the PENDING_DELETION state. For mor
information on deleting a backup, see DeleteBackup.
# Arguments
- `backup_id`: The ID of the backup to be restored. To find the ID of a backup, use the
DescribeBackups operation.
"""
function restore_backup(BackupId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudhsm_v2(
"RestoreBackup",
Dict{String,Any}("BackupId" => BackupId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function restore_backup(
BackupId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"RestoreBackup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("BackupId" => BackupId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_id, tag_list)
tag_resource(resource_id, tag_list, params::Dict{String,<:Any})
Adds or overwrites one or more tags for the specified AWS CloudHSM cluster.
# Arguments
- `resource_id`: The cluster identifier (ID) for the cluster that you are tagging. To find
the cluster ID, use DescribeClusters.
- `tag_list`: A list of one or more tags.
"""
function tag_resource(
ResourceId, TagList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"TagResource",
Dict{String,Any}("ResourceId" => ResourceId, "TagList" => TagList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceId,
TagList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceId" => ResourceId, "TagList" => TagList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_id, tag_key_list)
untag_resource(resource_id, tag_key_list, params::Dict{String,<:Any})
Removes the specified tag or tags from the specified AWS CloudHSM cluster.
# Arguments
- `resource_id`: The cluster identifier (ID) for the cluster whose tags you are removing.
To find the cluster ID, use DescribeClusters.
- `tag_key_list`: A list of one or more tag keys for the tags that you are removing.
Specify only the tag keys, not the tag values.
"""
function untag_resource(
ResourceId, TagKeyList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudhsm_v2(
"UntagResource",
Dict{String,Any}("ResourceId" => ResourceId, "TagKeyList" => TagKeyList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceId,
TagKeyList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudhsm_v2(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceId" => ResourceId, "TagKeyList" => TagKeyList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 35319 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudsearch
using AWS.Compat
using AWS.UUIDs
"""
build_suggesters(domain_name)
build_suggesters(domain_name, params::Dict{String,<:Any})
Indexes the search suggestions. For more information, see Configuring Suggesters in the
Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
"""
function build_suggesters(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"BuildSuggesters",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function build_suggesters(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"BuildSuggesters",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain(domain_name)
create_domain(domain_name, params::Dict{String,<:Any})
Creates a new search domain. For more information, see Creating a Search Domain in the
Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`: A name for the domain you are creating. Allowed characters are a-z
(lower-case letters), 0-9, and hyphen (-). Domain names must start with a letter or number
and be at least 3 and no more than 28 characters long.
"""
function create_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"CreateDomain",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"CreateDomain",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
define_analysis_scheme(analysis_scheme, domain_name)
define_analysis_scheme(analysis_scheme, domain_name, params::Dict{String,<:Any})
Configures an analysis scheme that can be applied to a text or text-array field to define
language-specific text processing options. For more information, see Configuring Analysis
Schemes in the Amazon CloudSearch Developer Guide.
# Arguments
- `analysis_scheme`:
- `domain_name`:
"""
function define_analysis_scheme(
AnalysisScheme, DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DefineAnalysisScheme",
Dict{String,Any}("AnalysisScheme" => AnalysisScheme, "DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function define_analysis_scheme(
AnalysisScheme,
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DefineAnalysisScheme",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AnalysisScheme" => AnalysisScheme, "DomainName" => DomainName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
define_expression(domain_name, expression)
define_expression(domain_name, expression, params::Dict{String,<:Any})
Configures an Expression for the search domain. Used to create new expressions and modify
existing ones. If the expression exists, the new configuration replaces the old one. For
more information, see Configuring Expressions in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `expression`:
"""
function define_expression(
DomainName, Expression; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DefineExpression",
Dict{String,Any}("DomainName" => DomainName, "Expression" => Expression);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function define_expression(
DomainName,
Expression,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DefineExpression",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "Expression" => Expression),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
define_index_field(domain_name, index_field)
define_index_field(domain_name, index_field, params::Dict{String,<:Any})
Configures an IndexField for the search domain. Used to create new fields and modify
existing ones. You must specify the name of the domain you are configuring and an index
field configuration. The index field configuration specifies a unique name, the index field
type, and the options you want to configure for the field. The options you can specify
depend on the IndexFieldType. If the field exists, the new configuration replaces the old
one. For more information, see Configuring Index Fields in the Amazon CloudSearch Developer
Guide.
# Arguments
- `domain_name`:
- `index_field`: The index field and field options you want to configure.
"""
function define_index_field(
DomainName, IndexField; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DefineIndexField",
Dict{String,Any}("DomainName" => DomainName, "IndexField" => IndexField);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function define_index_field(
DomainName,
IndexField,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DefineIndexField",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "IndexField" => IndexField),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
define_suggester(domain_name, suggester)
define_suggester(domain_name, suggester, params::Dict{String,<:Any})
Configures a suggester for a domain. A suggester enables you to display possible matches
before users finish typing their queries. When you configure a suggester, you must specify
the name of the text field you want to search for possible matches and a unique name for
the suggester. For more information, see Getting Search Suggestions in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `suggester`:
"""
function define_suggester(
DomainName, Suggester; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DefineSuggester",
Dict{String,Any}("DomainName" => DomainName, "Suggester" => Suggester);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function define_suggester(
DomainName,
Suggester,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DefineSuggester",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "Suggester" => Suggester),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_analysis_scheme(analysis_scheme_name, domain_name)
delete_analysis_scheme(analysis_scheme_name, domain_name, params::Dict{String,<:Any})
Deletes an analysis scheme. For more information, see Configuring Analysis Schemes in the
Amazon CloudSearch Developer Guide.
# Arguments
- `analysis_scheme_name`: The name of the analysis scheme you want to delete.
- `domain_name`:
"""
function delete_analysis_scheme(
AnalysisSchemeName, DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DeleteAnalysisScheme",
Dict{String,Any}(
"AnalysisSchemeName" => AnalysisSchemeName, "DomainName" => DomainName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_analysis_scheme(
AnalysisSchemeName,
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DeleteAnalysisScheme",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AnalysisSchemeName" => AnalysisSchemeName, "DomainName" => DomainName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain(domain_name)
delete_domain(domain_name, params::Dict{String,<:Any})
Permanently deletes a search domain and all of its data. Once a domain has been deleted, it
cannot be recovered. For more information, see Deleting a Search Domain in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to permanently delete.
"""
function delete_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"DeleteDomain",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DeleteDomain",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_expression(domain_name, expression_name)
delete_expression(domain_name, expression_name, params::Dict{String,<:Any})
Removes an Expression from the search domain. For more information, see Configuring
Expressions in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `expression_name`: The name of the Expression to delete.
"""
function delete_expression(
DomainName, ExpressionName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DeleteExpression",
Dict{String,Any}("DomainName" => DomainName, "ExpressionName" => ExpressionName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_expression(
DomainName,
ExpressionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DeleteExpression",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DomainName" => DomainName, "ExpressionName" => ExpressionName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_index_field(domain_name, index_field_name)
delete_index_field(domain_name, index_field_name, params::Dict{String,<:Any})
Removes an IndexField from the search domain. For more information, see Configuring Index
Fields in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `index_field_name`: The name of the index field your want to remove from the domain's
indexing options.
"""
function delete_index_field(
DomainName, IndexFieldName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DeleteIndexField",
Dict{String,Any}("DomainName" => DomainName, "IndexFieldName" => IndexFieldName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_index_field(
DomainName,
IndexFieldName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DeleteIndexField",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DomainName" => DomainName, "IndexFieldName" => IndexFieldName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_suggester(domain_name, suggester_name)
delete_suggester(domain_name, suggester_name, params::Dict{String,<:Any})
Deletes a suggester. For more information, see Getting Search Suggestions in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `suggester_name`: Specifies the name of the suggester you want to delete.
"""
function delete_suggester(
DomainName, SuggesterName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DeleteSuggester",
Dict{String,Any}("DomainName" => DomainName, "SuggesterName" => SuggesterName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_suggester(
DomainName,
SuggesterName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DeleteSuggester",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DomainName" => DomainName, "SuggesterName" => SuggesterName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_analysis_schemes(domain_name)
describe_analysis_schemes(domain_name, params::Dict{String,<:Any})
Gets the analysis schemes configured for a domain. An analysis scheme defines
language-specific text processing options for a text field. Can be limited to specific
analysis schemes by name. By default, shows all analysis schemes and includes any pending
changes to the configuration. Set the Deployed option to true to show the active
configuration and exclude pending changes. For more information, see Configuring Analysis
Schemes in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AnalysisSchemeNames"`: The analysis schemes you want to describe.
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
"""
function describe_analysis_schemes(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeAnalysisSchemes",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_analysis_schemes(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeAnalysisSchemes",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_availability_options(domain_name)
describe_availability_options(domain_name, params::Dict{String,<:Any})
Gets the availability options configured for a domain. By default, shows the configuration
with any pending changes. Set the Deployed option to true to show the active configuration
and exclude pending changes. For more information, see Configuring Availability Options in
the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
"""
function describe_availability_options(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeAvailabilityOptions",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_availability_options(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeAvailabilityOptions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_domain_endpoint_options(domain_name)
describe_domain_endpoint_options(domain_name, params::Dict{String,<:Any})
Returns the domain's endpoint options, specifically whether all requests to the domain must
arrive over HTTPS. For more information, see Configuring Domain Endpoint Options in the
Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`: A string that represents the name of a domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to retrieve the latest configuration (which might be in a
Processing state) or the current, active configuration. Defaults to false.
"""
function describe_domain_endpoint_options(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeDomainEndpointOptions",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_domain_endpoint_options(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeDomainEndpointOptions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_domains()
describe_domains(params::Dict{String,<:Any})
Gets information about the search domains owned by this account. Can be limited to specific
domains. Shows all domains by default. To get the number of searchable documents in a
domain, use the console or submit a matchall request to your domain's search endpoint:
q=matchall&amp;q.parser=structured&amp;size=0. For more information, see Getting
Information about a Search Domain in the Amazon CloudSearch Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DomainNames"`: The names of the domains you want to include in the response.
"""
function describe_domains(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"DescribeDomains"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_domains(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeDomains", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_expressions(domain_name)
describe_expressions(domain_name, params::Dict{String,<:Any})
Gets the expressions configured for the search domain. Can be limited to specific
expressions by name. By default, shows all expressions and includes any pending changes to
the configuration. Set the Deployed option to true to show the active configuration and
exclude pending changes. For more information, see Configuring Expressions in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
- `"ExpressionNames"`: Limits the DescribeExpressions response to the specified
expressions. If not specified, all expressions are shown.
"""
function describe_expressions(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"DescribeExpressions",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_expressions(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeExpressions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_index_fields(domain_name)
describe_index_fields(domain_name, params::Dict{String,<:Any})
Gets information about the index fields configured for the search domain. Can be limited to
specific fields by name. By default, shows all fields and includes any pending changes to
the configuration. Set the Deployed option to true to show the active configuration and
exclude pending changes. For more information, see Getting Domain Information in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
- `"FieldNames"`: A list of the index fields you want to describe. If not specified,
information is returned for all configured index fields.
"""
function describe_index_fields(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeIndexFields",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_index_fields(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeIndexFields",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_scaling_parameters(domain_name)
describe_scaling_parameters(domain_name, params::Dict{String,<:Any})
Gets the scaling parameters configured for a domain. A domain's scaling parameters specify
the desired search instance type and replication count. For more information, see
Configuring Scaling Options in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
"""
function describe_scaling_parameters(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeScalingParameters",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_scaling_parameters(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeScalingParameters",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_service_access_policies(domain_name)
describe_service_access_policies(domain_name, params::Dict{String,<:Any})
Gets information about the access policies that control access to the domain's document and
search endpoints. By default, shows the configuration with any pending changes. Set the
Deployed option to true to show the active configuration and exclude pending changes. For
more information, see Configuring Access for a Search Domain in the Amazon CloudSearch
Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
"""
function describe_service_access_policies(
DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"DescribeServiceAccessPolicies",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_service_access_policies(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeServiceAccessPolicies",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_suggesters(domain_name)
describe_suggesters(domain_name, params::Dict{String,<:Any})
Gets the suggesters configured for a domain. A suggester enables you to display possible
matches before users finish typing their queries. Can be limited to specific suggesters by
name. By default, shows all suggesters and includes any pending changes to the
configuration. Set the Deployed option to true to show the active configuration and exclude
pending changes. For more information, see Getting Search Suggestions in the Amazon
CloudSearch Developer Guide.
# Arguments
- `domain_name`: The name of the domain you want to describe.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Deployed"`: Whether to display the deployed configuration (true) or include any pending
changes (false). Defaults to false.
- `"SuggesterNames"`: The suggesters you want to describe.
"""
function describe_suggesters(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"DescribeSuggesters",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_suggesters(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"DescribeSuggesters",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
index_documents(domain_name)
index_documents(domain_name, params::Dict{String,<:Any})
Tells the search domain to start indexing its documents using the latest indexing options.
This operation must be invoked to activate options whose OptionStatus is
RequiresIndexDocuments.
# Arguments
- `domain_name`:
"""
function index_documents(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"IndexDocuments",
Dict{String,Any}("DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function index_documents(
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"IndexDocuments",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_domain_names()
list_domain_names(params::Dict{String,<:Any})
Lists all search domains owned by an account.
"""
function list_domain_names(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch(
"ListDomainNames"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_domain_names(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"ListDomainNames", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_availability_options(domain_name, multi_az)
update_availability_options(domain_name, multi_az, params::Dict{String,<:Any})
Configures the availability options for a domain. Enabling the Multi-AZ option expands an
Amazon CloudSearch domain to an additional Availability Zone in the same Region to increase
fault tolerance in the event of a service disruption. Changes to the Multi-AZ option can
take about half an hour to become active. For more information, see Configuring
Availability Options in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `multi_az`: You expand an existing search domain to a second Availability Zone by setting
the Multi-AZ option to true. Similarly, you can turn off the Multi-AZ option to downgrade
the domain to a single Availability Zone by setting the Multi-AZ option to false.
"""
function update_availability_options(
DomainName, MultiAZ; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"UpdateAvailabilityOptions",
Dict{String,Any}("DomainName" => DomainName, "MultiAZ" => MultiAZ);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_availability_options(
DomainName,
MultiAZ,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"UpdateAvailabilityOptions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DomainName" => DomainName, "MultiAZ" => MultiAZ),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_domain_endpoint_options(domain_endpoint_options, domain_name)
update_domain_endpoint_options(domain_endpoint_options, domain_name, params::Dict{String,<:Any})
Updates the domain's endpoint options, specifically whether all requests to the domain must
arrive over HTTPS. For more information, see Configuring Domain Endpoint Options in the
Amazon CloudSearch Developer Guide.
# Arguments
- `domain_endpoint_options`: Whether to require that all requests to the domain arrive over
HTTPS. We recommend Policy-Min-TLS-1-2-2019-07 for TLSSecurityPolicy. For compatibility
with older clients, the default is Policy-Min-TLS-1-0-2019-07.
- `domain_name`: A string that represents the name of a domain.
"""
function update_domain_endpoint_options(
DomainEndpointOptions, DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"UpdateDomainEndpointOptions",
Dict{String,Any}(
"DomainEndpointOptions" => DomainEndpointOptions, "DomainName" => DomainName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_domain_endpoint_options(
DomainEndpointOptions,
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"UpdateDomainEndpointOptions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DomainEndpointOptions" => DomainEndpointOptions,
"DomainName" => DomainName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_scaling_parameters(domain_name, scaling_parameters)
update_scaling_parameters(domain_name, scaling_parameters, params::Dict{String,<:Any})
Configures scaling parameters for a domain. A domain's scaling parameters specify the
desired search instance type and replication count. Amazon CloudSearch will still
automatically scale your domain based on the volume of data and traffic, but not below the
desired instance type and replication count. If the Multi-AZ option is enabled, these
values control the resources used per Availability Zone. For more information, see
Configuring Scaling Options in the Amazon CloudSearch Developer Guide.
# Arguments
- `domain_name`:
- `scaling_parameters`:
"""
function update_scaling_parameters(
DomainName, ScalingParameters; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"UpdateScalingParameters",
Dict{String,Any}(
"DomainName" => DomainName, "ScalingParameters" => ScalingParameters
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_scaling_parameters(
DomainName,
ScalingParameters,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"UpdateScalingParameters",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DomainName" => DomainName, "ScalingParameters" => ScalingParameters
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_service_access_policies(access_policies, domain_name)
update_service_access_policies(access_policies, domain_name, params::Dict{String,<:Any})
Configures the access rules that control access to the domain's document and search
endpoints. For more information, see Configuring Access for an Amazon CloudSearch Domain.
# Arguments
- `access_policies`: The access rules you want to configure. These rules replace any
existing rules.
- `domain_name`:
"""
function update_service_access_policies(
AccessPolicies, DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch(
"UpdateServiceAccessPolicies",
Dict{String,Any}("AccessPolicies" => AccessPolicies, "DomainName" => DomainName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_service_access_policies(
AccessPolicies,
DomainName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch(
"UpdateServiceAccessPolicies",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AccessPolicies" => AccessPolicies, "DomainName" => DomainName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 23519 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudsearch_domain
using AWS.Compat
using AWS.UUIDs
"""
search(q)
search(q, params::Dict{String,<:Any})
Retrieves a list of documents that match the specified search criteria. How you specify the
search criteria depends on which query parser you use. Amazon CloudSearch supports four
query parsers: simple: search all text and text-array fields for the specified string.
Search for phrases, individual terms, and prefixes. structured: search specific fields,
construct compound queries using Boolean operators, and use advanced features such as term
boosting and proximity searching. lucene: specify search criteria using the Apache Lucene
query parser syntax. dismax: specify search criteria using the simplified subset of the
Apache Lucene query parser syntax defined by the DisMax query parser. For more
information, see Searching Your Data in the Amazon CloudSearch Developer Guide. The
endpoint for submitting Search requests is domain-specific. You submit search requests to a
domain's search endpoint. To get the search endpoint for your domain, use the Amazon
CloudSearch configuration service DescribeDomains action. A domain's endpoints are also
displayed on the domain dashboard in the Amazon CloudSearch console.
# Arguments
- `q`: Specifies the search criteria for the request. How you specify the search criteria
depends on the query parser used for the request and the parser options specified in the
queryOptions parameter. By default, the simple query parser is used to process requests. To
use the structured, lucene, or dismax query parser, you must also specify the queryParser
parameter. For more information about specifying search criteria, see Searching Your Data
in the Amazon CloudSearch Developer Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cursor"`: Retrieves a cursor value you can use to page through large result sets. Use
the size parameter to control the number of hits to include in each response. You can
specify either the cursor or start parameter in a request; they are mutually exclusive. To
get the first cursor, set the cursor value to initial. In subsequent requests, specify the
cursor value returned in the hits section of the response. For more information, see
Paginating Results in the Amazon CloudSearch Developer Guide.
- `"expr"`: Defines one or more numeric expressions that can be used to sort results or
specify search or filter criteria. You can also specify expressions as return fields. You
specify the expressions in JSON using the form {\"EXPRESSIONNAME\":\"EXPRESSION\"}. You can
define and use multiple expressions in a search request. For example:
{\"expression1\":\"_score*rating\", \"expression2\":\"(1/rank)*year\"} For information
about the variables, operators, and functions you can use in expressions, see Writing
Expressions in the Amazon CloudSearch Developer Guide.
- `"facet"`: Specifies one or more fields for which to get facet information, and options
that control how the facet information is returned. Each specified field must be
facet-enabled in the domain configuration. The fields and options are specified in JSON
using the form
{\"FIELD\":{\"OPTION\":VALUE,\"OPTION:\"STRING\"},\"FIELD\":{\"OPTION\":VALUE,\"OPTION\":\"S
TRING\"}}. You can specify the following faceting options: buckets specifies an array of
the facet values or ranges to count. Ranges are specified using the same syntax that you
use to search for a range of values. For more information, see Searching for a Range of
Values in the Amazon CloudSearch Developer Guide. Buckets are returned in the order they
are specified in the request. The sort and size options are not valid if you specify
buckets. size specifies the maximum number of facets to include in the results. By
default, Amazon CloudSearch returns counts for the top 10. The size parameter is only valid
when you specify the sort option; it cannot be used in conjunction with buckets. sort
specifies how you want to sort the facets in the results: bucket or count. Specify bucket
to sort alphabetically or numerically by facet value (in ascending order). Specify count to
sort by the facet counts computed for each facet value (in descending order). To retrieve
facet counts for particular values or ranges of values, use the buckets option instead of
sort. If no facet options are specified, facet counts are computed for all field values,
the facets are sorted by facet count, and the top 10 facets are returned in the results. To
count particular buckets of values, use the buckets option. For example, the following
request uses the buckets option to calculate and return facet counts by decade.
{\"year\":{\"buckets\":[\"[1970,1979]\",\"[1980,1989]\",\"[1990,1999]\",\"[2000,2009]\",\"[2
010,}\"]}} To sort facets by facet count, use the count option. For example, the following
request sets the sort option to count to sort the facet values by facet count, with the
facet values that have the most matching documents listed first. Setting the size option to
3 returns only the top three facet values. {\"year\":{\"sort\":\"count\",\"size\":3}} To
sort the facets by value, use the bucket option. For example, the following request sets
the sort option to bucket to sort the facet values numerically by year, with earliest year
listed first. {\"year\":{\"sort\":\"bucket\"}} For more information, see Getting and
Using Facet Information in the Amazon CloudSearch Developer Guide.
- `"fq"`: Specifies a structured query that filters the results of a search without
affecting how the results are scored and sorted. You use filterQuery in conjunction with
the query parameter to filter the documents that match the constraints specified in the
query parameter. Specifying a filter controls only which matching documents are included in
the results, it has no effect on how they are scored and sorted. The filterQuery parameter
supports the full structured query syntax. For more information about using filters, see
Filtering Matching Documents in the Amazon CloudSearch Developer Guide.
- `"highlight"`: Retrieves highlights for matches in the specified text or text-array
fields. Each specified field must be highlight enabled in the domain configuration. The
fields and options are specified in JSON using the form
{\"FIELD\":{\"OPTION\":VALUE,\"OPTION:\"STRING\"},\"FIELD\":{\"OPTION\":VALUE,\"OPTION\":\"S
TRING\"}}. You can specify the following highlight options: format: specifies the format
of the data in the text field: text or html. When data is returned as HTML, all
non-alphanumeric characters are encoded. The default is html. max_phrases: specifies the
maximum number of occurrences of the search term(s) you want to highlight. By default, the
first occurrence is highlighted. pre_tag: specifies the string to prepend to an
occurrence of a search term. The default for HTML highlights is &lt;em&gt;. The
default for text highlights is *. post_tag: specifies the string to append to an
occurrence of a search term. The default for HTML highlights is &lt;/em&gt;. The
default for text highlights is *. If no highlight options are specified for a field, the
returned field text is treated as HTML and the first match is highlighted with emphasis
tags: &lt;em>search-term&lt;/em&gt;. For example, the following request
retrieves highlights for the actors and title fields. { \"actors\": {}, \"title\":
{\"format\": \"text\",\"max_phrases\": 2,\"pre_tag\": \"\",\"post_tag\": \"\"} }
- `"partial"`: Enables partial results to be returned if one or more index partitions are
unavailable. When your search index is partitioned across multiple search instances, by
default Amazon CloudSearch only returns results if every partition can be queried. This
means that the failure of a single search instance can result in 5xx (internal server)
errors. When you enable partial results, Amazon CloudSearch returns whatever results are
available and includes the percentage of documents searched in the search results
(percent-searched). This enables you to more gracefully degrade your users' search
experience. For example, rather than displaying no results, you could display the partial
results and a message indicating that the results might be incomplete due to a temporary
system outage.
- `"q.options"`: Configures options for the query parser specified in the queryParser
parameter. You specify the options in JSON using the following form
{\"OPTION1\":\"VALUE1\",\"OPTION2\":VALUE2\"...\"OPTIONN\":\"VALUEN\"}. The options you can
configure vary according to which parser you use: defaultOperator: The default operator
used to combine individual terms in the search string. For example: defaultOperator: 'or'.
For the dismax parser, you specify a percentage that represents the percentage of terms in
the search string (rounded down) that must match, rather than a default operator. A value
of 0% is the equivalent to OR, and a value of 100% is equivalent to AND. The percentage
must be specified as a value in the range 0-100 followed by the percent (%) symbol. For
example, defaultOperator: 50%. Valid values: and, or, a percentage in the range 0%-100%
(dismax). Default: and (simple, structured, lucene) or 100 (dismax). Valid for: simple,
structured, lucene, and dismax. fields: An array of the fields to search when no fields are
specified in a search. If no fields are specified in a search and this option is not
specified, all text and text-array fields are searched. You can specify a weight for each
field to control the relative importance of each field when Amazon CloudSearch calculates
relevance scores. To specify a field weight, append a caret (^) symbol and the weight to
the field name. For example, to boost the importance of the title field over the
description field you could specify: \"fields\":[\"title^5\",\"description\"]. Valid
values: The name of any configured field and an optional numeric value greater than zero.
Default: All text and text-array fields. Valid for: simple, structured, lucene, and dismax.
operators: An array of the operators or special characters you want to disable for the
simple query parser. If you disable the and, or, or not operators, the corresponding
operators (+, |, -) have no special meaning and are dropped from the search string.
Similarly, disabling prefix disables the wildcard operator (*) and disabling phrase
disables the ability to search for phrases by enclosing phrases in double quotes. Disabling
precedence disables the ability to control order of precedence using parentheses. Disabling
near disables the ability to use the ~ operator to perform a sloppy phrase search.
Disabling the fuzzy operator disables the ability to use the ~ operator to perform a fuzzy
search. escape disables the ability to use a backslash () to escape special characters
within the search string. Disabling whitespace is an advanced option that prevents the
parser from tokenizing on whitespace, which can be useful for Vietnamese. (It prevents
Vietnamese words from being split incorrectly.) For example, you could disable all
operators other than the phrase operator to support just simple term and phrase queries:
\"operators\":[\"and\",\"not\",\"or\", \"prefix\"]. Valid values: and, escape, fuzzy, near,
not, or, phrase, precedence, prefix, whitespace. Default: All operators and special
characters are enabled. Valid for: simple. phraseFields: An array of the text or text-array
fields you want to use for phrase searches. When the terms in the search string appear in
close proximity within a field, the field scores higher. You can specify a weight for each
field to boost that score. The phraseSlop option controls how much the matches can deviate
from the search string and still be boosted. To specify a field weight, append a caret (^)
symbol and the weight to the field name. For example, to boost phrase matches in the title
field over the abstract field, you could specify: \"phraseFields\":[\"title^3\", \"plot\"]
Valid values: The name of any text or text-array field and an optional numeric value
greater than zero. Default: No fields. If you don't specify any fields with phraseFields,
proximity scoring is disabled even if phraseSlop is specified. Valid for: dismax.
phraseSlop: An integer value that specifies how much matches can deviate from the search
phrase and still be boosted according to the weights specified in the phraseFields option;
for example, phraseSlop: 2. You must also specify phraseFields to enable proximity scoring.
Valid values: positive integers. Default: 0. Valid for: dismax. explicitPhraseSlop: An
integer value that specifies how much a match can deviate from the search phrase when the
phrase is enclosed in double quotes in the search string. (Phrases that exceed this
proximity distance are not considered a match.) For example, to specify a slop of three for
dismax phrase queries, you would specify \"explicitPhraseSlop\":3. Valid values: positive
integers. Default: 0. Valid for: dismax. tieBreaker: When a term in the search string is
found in a document's field, a score is calculated for that field based on how common the
word is in that field compared to other documents. If the term occurs in multiple fields
within a document, by default only the highest scoring field contributes to the document's
overall score. You can specify a tieBreaker value to enable the matches in lower-scoring
fields to contribute to the document's score. That way, if two documents have the same max
field score for a particular term, the score for the document that has matches in more
fields will be higher. The formula for calculating the score with a tieBreaker is (max
field score) + (tieBreaker) * (sum of the scores for the rest of the matching fields). Set
tieBreaker to 0 to disregard all but the highest scoring field (pure max):
\"tieBreaker\":0. Set to 1 to sum the scores from all fields (pure sum): \"tieBreaker\":1.
Valid values: 0.0 to 1.0. Default: 0.0. Valid for: dismax.
- `"q.parser"`: Specifies which query parser to use to process the request. If queryParser
is not specified, Amazon CloudSearch uses the simple query parser. Amazon CloudSearch
supports four query parsers: simple: perform simple searches of text and text-array
fields. By default, the simple query parser searches all text and text-array fields. You
can specify which fields to search by with the queryOptions parameter. If you prefix a
search term with a plus sign (+) documents must contain the term to be considered a match.
(This is the default, unless you configure the default operator with the queryOptions
parameter.) You can use the - (NOT), | (OR), and * (wildcard) operators to exclude
particular terms, find results that match any of the specified terms, or search for a
prefix. To search for a phrase rather than individual terms, enclose the phrase in double
quotes. For more information, see Searching for Text in the Amazon CloudSearch Developer
Guide. structured: perform advanced searches by combining multiple expressions to define
the search criteria. You can also search within particular fields, search for values and
ranges of values, and use advanced options such as term boosting, matchall, and near. For
more information, see Constructing Compound Queries in the Amazon CloudSearch Developer
Guide. lucene: search using the Apache Lucene query parser syntax. For more information,
see Apache Lucene Query Parser Syntax. dismax: search using the simplified subset of the
Apache Lucene query parser syntax defined by the DisMax query parser. For more information,
see DisMax Query Parser Syntax.
- `"return"`: Specifies the field and expression values to include in the response.
Multiple fields or expressions are specified as a comma-separated list. By default, a
search response includes all return enabled fields (_all_fields). To return only the
document IDs for the matching documents, specify _no_fields. To retrieve the relevance
score calculated for each document, specify _score.
- `"size"`: Specifies the maximum number of search hits to include in the response.
- `"sort"`: Specifies the fields or custom expressions to use to sort the search results.
Multiple fields or expressions are specified as a comma-separated list. You must specify
the sort direction (asc or desc) for each field; for example, year desc,title asc. To use a
field to sort results, the field must be sort-enabled in the domain configuration. Array
type fields cannot be used for sorting. If no sort parameter is specified, results are
sorted by their default relevance scores in descending order: _score desc. You can also
sort by document ID (_id asc) and version (_version desc). For more information, see
Sorting Results in the Amazon CloudSearch Developer Guide.
- `"start"`: Specifies the offset of the first search hit you want to return. Note that the
result set is zero-based; the first result is at index 0. You can specify either the start
or cursor parameter in a request, they are mutually exclusive. For more information, see
Paginating Results in the Amazon CloudSearch Developer Guide.
- `"stats"`: Specifies one or more fields for which to get statistics information. Each
specified field must be facet-enabled in the domain configuration. The fields are specified
in JSON using the form: {\"FIELD-A\":{},\"FIELD-B\":{}} There are currently no options
supported for statistics.
"""
function search(q; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch_domain(
"GET",
"/2013-01-01/search?format=sdk&pretty=true",
Dict{String,Any}("q" => q);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function search(
q, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch_domain(
"GET",
"/2013-01-01/search?format=sdk&pretty=true",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("q" => q), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
suggest(q, suggester)
suggest(q, suggester, params::Dict{String,<:Any})
Retrieves autocomplete suggestions for a partial query string. You can use suggestions
enable you to display likely matches before users finish typing. In Amazon CloudSearch,
suggestions are based on the contents of a particular text field. When you request
suggestions, Amazon CloudSearch finds all of the documents whose values in the suggester
field start with the specified query string. The beginning of the field must match the
query string to be considered a match. For more information about configuring suggesters
and retrieving suggestions, see Getting Suggestions in the Amazon CloudSearch Developer
Guide. The endpoint for submitting Suggest requests is domain-specific. You submit suggest
requests to a domain's search endpoint. To get the search endpoint for your domain, use the
Amazon CloudSearch configuration service DescribeDomains action. A domain's endpoints are
also displayed on the domain dashboard in the Amazon CloudSearch console.
# Arguments
- `q`: Specifies the string for which you want to get suggestions.
- `suggester`: Specifies the name of the suggester to use to find suggested matches.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"size"`: Specifies the maximum number of suggestions to return.
"""
function suggest(q, suggester; aws_config::AbstractAWSConfig=global_aws_config())
return cloudsearch_domain(
"GET",
"/2013-01-01/suggest?format=sdk&pretty=true",
Dict{String,Any}("q" => q, "suggester" => suggester);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function suggest(
q,
suggester,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch_domain(
"GET",
"/2013-01-01/suggest?format=sdk&pretty=true",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("q" => q, "suggester" => suggester), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
upload_documents(content-_type, documents)
upload_documents(content-_type, documents, params::Dict{String,<:Any})
Posts a batch of documents to a search domain for indexing. A document batch is a
collection of add and delete operations that represent the documents you want to add,
update, or delete from your domain. Batches can be described in either JSON or XML. Each
item that you want Amazon CloudSearch to return as a search result (such as a product) is
represented as a document. Every document has a unique ID and one or more fields that
contain the data that you want to search and return in results. Individual documents cannot
contain more than 1 MB of data. The entire batch cannot exceed 5 MB. To get the best
possible upload performance, group add and delete operations in batches that are close the
5 MB limit. Submitting a large volume of single-document batches can overload a domain's
document service. The endpoint for submitting UploadDocuments requests is domain-specific.
To get the document endpoint for your domain, use the Amazon CloudSearch configuration
service DescribeDomains action. A domain's endpoints are also displayed on the domain
dashboard in the Amazon CloudSearch console. For more information about formatting your
data for Amazon CloudSearch, see Preparing Your Data in the Amazon CloudSearch Developer
Guide. For more information about uploading data for indexing, see Uploading Data in the
Amazon CloudSearch Developer Guide.
# Arguments
- `content-_type`: The format of the batch you are uploading. Amazon CloudSearch supports
two document batch formats: application/json application/xml
- `documents`: A batch of documents formatted in JSON or HTML.
"""
function upload_documents(
Content_Type, documents; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudsearch_domain(
"POST",
"/2013-01-01/documents/batch?format=sdk",
Dict{String,Any}(
"documents" => documents,
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function upload_documents(
Content_Type,
documents,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudsearch_domain(
"POST",
"/2013-01-01/documents/batch?format=sdk",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"documents" => documents,
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 95056 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudtrail
using AWS.Compat
using AWS.UUIDs
"""
add_tags(resource_id, tags_list)
add_tags(resource_id, tags_list, params::Dict{String,<:Any})
Adds one or more tags to a trail, event data store, or channel, up to a limit of 50.
Overwrites an existing tag's value when a new value is specified for an existing tag key.
Tag key names must be unique; you cannot have two keys with the same name but different
values. If you specify a key without a value, the tag will be created with the specified
key and a value of null. You can tag a trail or event data store that applies to all Amazon
Web Services Regions only from the Region in which the trail or event data store was
created (also known as its home Region).
# Arguments
- `resource_id`: Specifies the ARN of the trail, event data store, or channel to which one
or more tags will be added. The format of a trail ARN is:
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail The format of an event data store
ARN is:
arn:aws:cloudtrail:us-east-2:123456789012:eventdatastore/EXAMPLE-f852-4e8f-8bd1-bcf6cEXAMPLE
The format of a channel ARN is:
arn:aws:cloudtrail:us-east-2:123456789012:channel/01234567890
- `tags_list`: Contains a list of tags, up to a limit of 50
"""
function add_tags(ResourceId, TagsList; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"AddTags",
Dict{String,Any}("ResourceId" => ResourceId, "TagsList" => TagsList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_tags(
ResourceId,
TagsList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"AddTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceId" => ResourceId, "TagsList" => TagsList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_query(query_id)
cancel_query(query_id, params::Dict{String,<:Any})
Cancels a query if the query is not in a terminated state, such as CANCELLED, FAILED,
TIMED_OUT, or FINISHED. You must specify an ARN value for EventDataStore. The ID of the
query that you want to cancel is also required. When you run CancelQuery, the query status
might show as CANCELLED even if the operation is not yet finished.
# Arguments
- `query_id`: The ID of the query that you want to cancel. The QueryId comes from the
response of a StartQuery operation.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventDataStore"`: The ARN (or the ID suffix of the ARN) of an event data store on which
the specified query is running.
"""
function cancel_query(QueryId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"CancelQuery",
Dict{String,Any}("QueryId" => QueryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_query(
QueryId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"CancelQuery",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("QueryId" => QueryId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_channel(destinations, name, source)
create_channel(destinations, name, source, params::Dict{String,<:Any})
Creates a channel for CloudTrail to ingest events from a partner or external source. After
you create a channel, a CloudTrail Lake event data store can log events from the partner or
source that you specify.
# Arguments
- `destinations`: One or more event data stores to which events arriving through a channel
will be logged.
- `name`: The name of the channel.
- `source`: The name of the partner or external event source. You cannot change this name
after you create the channel. A maximum of one channel is allowed per source. A source can
be either Custom for all valid non-Amazon Web Services events, or the name of a partner
event source. For information about the source names for available partners, see Additional
information about integration partners in the CloudTrail User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`:
"""
function create_channel(
Destinations, Name, Source; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"CreateChannel",
Dict{String,Any}(
"Destinations" => Destinations, "Name" => Name, "Source" => Source
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_channel(
Destinations,
Name,
Source,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"CreateChannel",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Destinations" => Destinations, "Name" => Name, "Source" => Source
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_event_data_store(name)
create_event_data_store(name, params::Dict{String,<:Any})
Creates a new event data store.
# Arguments
- `name`: The name of the event data store.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdvancedEventSelectors"`: The advanced event selectors to use to select the events for
the data store. You can configure up to five advanced event selectors for each event data
store. For more information about how to use advanced event selectors to log CloudTrail
events, see Log events by using advanced event selectors in the CloudTrail User Guide. For
more information about how to use advanced event selectors to include Config configuration
items in your event data store, see Create an event data store for Config configuration
items in the CloudTrail User Guide. For more information about how to use advanced event
selectors to include events outside of Amazon Web Services events in your event data store,
see Create an integration to log events from outside Amazon Web Services in the CloudTrail
User Guide.
- `"BillingMode"`: The billing mode for the event data store determines the cost for
ingesting events and the default and maximum retention period for the event data store. The
following are the possible values: EXTENDABLE_RETENTION_PRICING - This billing mode is
generally recommended if you want a flexible retention period of up to 3653 days (about 10
years). The default retention period for this billing mode is 366 days.
FIXED_RETENTION_PRICING - This billing mode is recommended if you expect to ingest more
than 25 TB of event data per month and need a retention period of up to 2557 days (about 7
years). The default retention period for this billing mode is 2557 days. The default
value is EXTENDABLE_RETENTION_PRICING. For more information about CloudTrail pricing, see
CloudTrail Pricing and Managing CloudTrail Lake costs.
- `"KmsKeyId"`: Specifies the KMS key ID to use to encrypt the events delivered by
CloudTrail. The value can be an alias name prefixed by alias/, a fully specified ARN to an
alias, a fully specified ARN to a key, or a globally unique identifier. Disabling or
deleting the KMS key, or removing CloudTrail permissions on the key, prevents CloudTrail
from logging events to the event data store, and prevents users from querying the data in
the event data store that was encrypted with the key. After you associate an event data
store with a KMS key, the KMS key cannot be removed or changed. Before you disable or
delete a KMS key that you are using with an event data store, delete or back up your event
data store. CloudTrail also supports KMS multi-Region keys. For more information about
multi-Region keys, see Using multi-Region keys in the Key Management Service Developer
Guide. Examples: alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:key/12345678-1234-1234-1234-123456789012
12345678-1234-1234-1234-123456789012
- `"MultiRegionEnabled"`: Specifies whether the event data store includes events from all
Regions, or only from the Region in which the event data store is created.
- `"OrganizationEnabled"`: Specifies whether an event data store collects events logged for
an organization in Organizations.
- `"RetentionPeriod"`: The retention period of the event data store, in days. If
BillingMode is set to EXTENDABLE_RETENTION_PRICING, you can set a retention period of up to
3653 days, the equivalent of 10 years. If BillingMode is set to FIXED_RETENTION_PRICING,
you can set a retention period of up to 2557 days, the equivalent of seven years.
CloudTrail Lake determines whether to retain an event by checking if the eventTime of the
event is within the specified retention period. For example, if you set a retention period
of 90 days, CloudTrail will remove events when the eventTime is older than 90 days. If you
plan to copy trail events to this event data store, we recommend that you consider both the
age of the events that you want to copy as well as how long you want to keep the copied
events in your event data store. For example, if you copy trail events that are 5 years old
and specify a retention period of 7 years, the event data store will retain those events
for two years.
- `"StartIngestion"`: Specifies whether the event data store should start ingesting live
events. The default is true.
- `"TagsList"`:
- `"TerminationProtectionEnabled"`: Specifies whether termination protection is enabled for
the event data store. If termination protection is enabled, you cannot delete the event
data store until termination protection is disabled.
"""
function create_event_data_store(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"CreateEventDataStore",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_event_data_store(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"CreateEventDataStore",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_trail(name, s3_bucket_name)
create_trail(name, s3_bucket_name, params::Dict{String,<:Any})
Creates a trail that specifies the settings for delivery of log data to an Amazon S3
bucket.
# Arguments
- `name`: Specifies the name of the trail. The name must meet the following requirements:
Contain only ASCII letters (a-z, A-Z), numbers (0-9), periods (.), underscores (_), or
dashes (-) Start with a letter or number, and end with a letter or number Be between 3
and 128 characters Have no adjacent periods, underscores or dashes. Names like
my-_namespace and my--namespace are not valid. Not be in IP address format (for example,
192.168.5.4)
- `s3_bucket_name`: Specifies the name of the Amazon S3 bucket designated for publishing
log files. For information about bucket naming rules, see Bucket naming rules in the Amazon
Simple Storage Service User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CloudWatchLogsLogGroupArn"`: Specifies a log group name using an Amazon Resource Name
(ARN), a unique identifier that represents the log group to which CloudTrail logs will be
delivered. You must use a log group that exists in your account. Not required unless you
specify CloudWatchLogsRoleArn.
- `"CloudWatchLogsRoleArn"`: Specifies the role for the CloudWatch Logs endpoint to assume
to write to a user's log group. You must use a role that exists in your account.
- `"EnableLogFileValidation"`: Specifies whether log file integrity validation is enabled.
The default is false. When you disable log file integrity validation, the chain of digest
files is broken after one hour. CloudTrail does not create digest files for log files that
were delivered during a period in which log file integrity validation was disabled. For
example, if you enable log file integrity validation at noon on January 1, disable it at
noon on January 2, and re-enable it at noon on January 10, digest files will not be created
for the log files delivered from noon on January 2 to noon on January 10. The same applies
whenever you stop CloudTrail logging or delete a trail.
- `"IncludeGlobalServiceEvents"`: Specifies whether the trail is publishing events from
global services such as IAM to the log files.
- `"IsMultiRegionTrail"`: Specifies whether the trail is created in the current Region or
in all Regions. The default is false, which creates a trail only in the Region where you
are signed in. As a best practice, consider creating trails that log events in all Regions.
- `"IsOrganizationTrail"`: Specifies whether the trail is created for all accounts in an
organization in Organizations, or only for the current Amazon Web Services account. The
default is false, and cannot be true unless the call is made on behalf of an Amazon Web
Services account that is the management account or delegated administrator account for an
organization in Organizations.
- `"KmsKeyId"`: Specifies the KMS key ID to use to encrypt the logs delivered by
CloudTrail. The value can be an alias name prefixed by alias/, a fully specified ARN to an
alias, a fully specified ARN to a key, or a globally unique identifier. CloudTrail also
supports KMS multi-Region keys. For more information about multi-Region keys, see Using
multi-Region keys in the Key Management Service Developer Guide. Examples:
alias/MyAliasName arn:aws:kms:us-east-2:123456789012:alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:key/12345678-1234-1234-1234-123456789012
12345678-1234-1234-1234-123456789012
- `"S3KeyPrefix"`: Specifies the Amazon S3 key prefix that comes after the name of the
bucket you have designated for log file delivery. For more information, see Finding Your
CloudTrail Log Files. The maximum length is 200 characters.
- `"SnsTopicName"`: Specifies the name of the Amazon SNS topic defined for notification of
log file delivery. The maximum length is 256 characters.
- `"TagsList"`:
"""
function create_trail(Name, S3BucketName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"CreateTrail",
Dict{String,Any}("Name" => Name, "S3BucketName" => S3BucketName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_trail(
Name,
S3BucketName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"CreateTrail",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Name" => Name, "S3BucketName" => S3BucketName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_channel(channel)
delete_channel(channel, params::Dict{String,<:Any})
Deletes a channel.
# Arguments
- `channel`: The ARN or the UUID value of the channel that you want to delete.
"""
function delete_channel(Channel; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"DeleteChannel",
Dict{String,Any}("Channel" => Channel);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_channel(
Channel, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DeleteChannel",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Channel" => Channel), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_event_data_store(event_data_store)
delete_event_data_store(event_data_store, params::Dict{String,<:Any})
Disables the event data store specified by EventDataStore, which accepts an event data
store ARN. After you run DeleteEventDataStore, the event data store enters a
PENDING_DELETION state, and is automatically deleted after a wait period of seven days.
TerminationProtectionEnabled must be set to False on the event data store and the
FederationStatus must be DISABLED. You cannot delete an event data store if
TerminationProtectionEnabled is True or the FederationStatus is ENABLED. After you run
DeleteEventDataStore on an event data store, you cannot run ListQueries, DescribeQuery, or
GetQueryResults on queries that are using an event data store in a PENDING_DELETION state.
An event data store in the PENDING_DELETION state does not incur costs.
# Arguments
- `event_data_store`: The ARN (or the ID suffix of the ARN) of the event data store to
delete.
"""
function delete_event_data_store(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DeleteEventDataStore",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_event_data_store(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"DeleteEventDataStore",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resource_policy(resource_arn)
delete_resource_policy(resource_arn, params::Dict{String,<:Any})
Deletes the resource-based policy attached to the CloudTrail channel.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudTrail channel you're deleting
the resource-based policy from. The following is the format of a resource ARN:
arn:aws:cloudtrail:us-east-2:123456789012:channel/MyChannel.
"""
function delete_resource_policy(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DeleteResourcePolicy",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resource_policy(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"DeleteResourcePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_trail(name)
delete_trail(name, params::Dict{String,<:Any})
Deletes a trail. This operation must be called from the Region in which the trail was
created. DeleteTrail cannot be called on the shadow trails (replicated trails in other
Regions) of a trail that is enabled in all Regions.
# Arguments
- `name`: Specifies the name or the CloudTrail ARN of the trail to be deleted. The
following is the format of a trail ARN.
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
"""
function delete_trail(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"DeleteTrail",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_trail(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DeleteTrail",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_organization_delegated_admin(delegated_admin_account_id)
deregister_organization_delegated_admin(delegated_admin_account_id, params::Dict{String,<:Any})
Removes CloudTrail delegated administrator permissions from a member account in an
organization.
# Arguments
- `delegated_admin_account_id`: A delegated administrator account ID. This is a member
account in an organization that is currently designated as a delegated administrator.
"""
function deregister_organization_delegated_admin(
DelegatedAdminAccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DeregisterOrganizationDelegatedAdmin",
Dict{String,Any}("DelegatedAdminAccountId" => DelegatedAdminAccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_organization_delegated_admin(
DelegatedAdminAccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"DeregisterOrganizationDelegatedAdmin",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("DelegatedAdminAccountId" => DelegatedAdminAccountId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_query()
describe_query(params::Dict{String,<:Any})
Returns metadata about a query, including query run time in milliseconds, number of events
scanned and matched, and query status. If the query results were delivered to an S3 bucket,
the response also provides the S3 URI and the delivery status. You must specify either a
QueryID or a QueryAlias. Specifying the QueryAlias parameter returns information about the
last query run for the alias.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventDataStore"`: The ARN (or the ID suffix of the ARN) of an event data store on which
the specified query was run.
- `"QueryAlias"`: The alias that identifies a query template.
- `"QueryId"`: The query ID.
"""
function describe_query(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"DescribeQuery"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_query(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DescribeQuery", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_trails()
describe_trails(params::Dict{String,<:Any})
Retrieves settings for one or more trails associated with the current Region for your
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeShadowTrails"`: Specifies whether to include shadow trails in the response. A
shadow trail is the replication in a Region of a trail that was created in a different
Region, or in the case of an organization trail, the replication of an organization trail
in member accounts. If you do not include shadow trails, organization trails in a member
account and Region replication trails will not be returned. The default is true.
- `"trailNameList"`: Specifies a list of trail names, trail ARNs, or both, of the trails to
describe. The format of a trail ARN is:
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail If an empty list is specified,
information for the trail in the current Region is returned. If an empty list is
specified and IncludeShadowTrails is false, then information for all trails in the current
Region is returned. If an empty list is specified and IncludeShadowTrails is null or
true, then information for all trails in the current Region and any associated shadow
trails in other Regions is returned. If one or more trail names are specified,
information is returned only if the names match the names of trails belonging only to the
current Region and current account. To return information about a trail in another Region,
you must specify its trail ARN.
"""
function describe_trails(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"DescribeTrails"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_trails(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DescribeTrails", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
disable_federation(event_data_store)
disable_federation(event_data_store, params::Dict{String,<:Any})
Disables Lake query federation on the specified event data store. When you disable
federation, CloudTrail disables the integration with Glue, Lake Formation, and Amazon
Athena. After disabling Lake query federation, you can no longer query your event data in
Amazon Athena. No CloudTrail Lake data is deleted when you disable federation and you can
continue to run queries in CloudTrail Lake.
# Arguments
- `event_data_store`: The ARN (or ID suffix of the ARN) of the event data store for which
you want to disable Lake query federation.
"""
function disable_federation(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"DisableFederation",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_federation(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"DisableFederation",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_federation(event_data_store, federation_role_arn)
enable_federation(event_data_store, federation_role_arn, params::Dict{String,<:Any})
Enables Lake query federation on the specified event data store. Federating an event data
store lets you view the metadata associated with the event data store in the Glue Data
Catalog and run SQL queries against your event data using Amazon Athena. The table metadata
stored in the Glue Data Catalog lets the Athena query engine know how to find, read, and
process the data that you want to query. When you enable Lake query federation, CloudTrail
creates a managed database named aws:cloudtrail (if the database doesn't already exist) and
a managed federated table in the Glue Data Catalog. The event data store ID is used for the
table name. CloudTrail registers the role ARN and event data store in Lake Formation, the
service responsible for allowing fine-grained access control of the federated resources in
the Glue Data Catalog. For more information about Lake query federation, see Federate an
event data store.
# Arguments
- `event_data_store`: The ARN (or ID suffix of the ARN) of the event data store for which
you want to enable Lake query federation.
- `federation_role_arn`: The ARN of the federation role to use for the event data store.
Amazon Web Services services like Lake Formation use this federation role to access data
for the federated event data store. The federation role must exist in your account and
provide the required minimum permissions.
"""
function enable_federation(
EventDataStore, FederationRoleArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"EnableFederation",
Dict{String,Any}(
"EventDataStore" => EventDataStore, "FederationRoleArn" => FederationRoleArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_federation(
EventDataStore,
FederationRoleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"EnableFederation",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EventDataStore" => EventDataStore,
"FederationRoleArn" => FederationRoleArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_channel(channel)
get_channel(channel, params::Dict{String,<:Any})
Returns information about a specific channel.
# Arguments
- `channel`: The ARN or UUID of a channel.
"""
function get_channel(Channel; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetChannel",
Dict{String,Any}("Channel" => Channel);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_channel(
Channel, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetChannel",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Channel" => Channel), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_event_data_store(event_data_store)
get_event_data_store(event_data_store, params::Dict{String,<:Any})
Returns information about an event data store specified as either an ARN or the ID portion
of the ARN.
# Arguments
- `event_data_store`: The ARN (or ID suffix of the ARN) of the event data store about which
you want information.
"""
function get_event_data_store(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetEventDataStore",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_event_data_store(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"GetEventDataStore",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_event_selectors(trail_name)
get_event_selectors(trail_name, params::Dict{String,<:Any})
Describes the settings for the event selectors that you configured for your trail. The
information returned for your event selectors includes the following: If your event
selector includes read-only events, write-only events, or all events. This applies to both
management events and data events. If your event selector includes management events.
If your event selector includes data events, the resources on which you are logging data
events. For more information about logging management and data events, see the following
topics in the CloudTrail User Guide: Logging management events Logging data events
# Arguments
- `trail_name`: Specifies the name of the trail or trail ARN. If you specify a trail name,
the string must meet the following requirements: Contain only ASCII letters (a-z, A-Z),
numbers (0-9), periods (.), underscores (_), or dashes (-) Start with a letter or number,
and end with a letter or number Be between 3 and 128 characters Have no adjacent
periods, underscores or dashes. Names like my-_namespace and my--namespace are not valid.
Not be in IP address format (for example, 192.168.5.4) If you specify a trail ARN, it
must be in the format: arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
"""
function get_event_selectors(TrailName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetEventSelectors",
Dict{String,Any}("TrailName" => TrailName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_event_selectors(
TrailName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"GetEventSelectors",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TrailName" => TrailName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_import(import_id)
get_import(import_id, params::Dict{String,<:Any})
Returns information about a specific import.
# Arguments
- `import_id`: The ID for the import.
"""
function get_import(ImportId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetImport",
Dict{String,Any}("ImportId" => ImportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_import(
ImportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"GetImport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ImportId" => ImportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_insight_selectors()
get_insight_selectors(params::Dict{String,<:Any})
Describes the settings for the Insights event selectors that you configured for your trail
or event data store. GetInsightSelectors shows if CloudTrail Insights event logging is
enabled on the trail or event data store, and if it is, which Insights types are enabled.
If you run GetInsightSelectors on a trail or event data store that does not have Insights
events enabled, the operation throws the exception InsightNotEnabledException Specify
either the EventDataStore parameter to get Insights event selectors for an event data
store, or the TrailName parameter to the get Insights event selectors for a trail. You
cannot specify these parameters together. For more information, see Logging CloudTrail
Insights events in the CloudTrail User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventDataStore"`: Specifies the ARN (or ID suffix of the ARN) of the event data store
for which you want to get Insights selectors. You cannot use this parameter with the
TrailName parameter.
- `"TrailName"`: Specifies the name of the trail or trail ARN. If you specify a trail name,
the string must meet the following requirements: Contain only ASCII letters (a-z, A-Z),
numbers (0-9), periods (.), underscores (_), or dashes (-) Start with a letter or number,
and end with a letter or number Be between 3 and 128 characters Have no adjacent
periods, underscores or dashes. Names like my-_namespace and my--namespace are not valid.
Not be in IP address format (for example, 192.168.5.4) If you specify a trail ARN, it
must be in the format: arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail You cannot
use this parameter with the EventDataStore parameter.
"""
function get_insight_selectors(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetInsightSelectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_insight_selectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetInsightSelectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_query_results(query_id)
get_query_results(query_id, params::Dict{String,<:Any})
Gets event data results of a query. You must specify the QueryID value returned by the
StartQuery operation.
# Arguments
- `query_id`: The ID of the query for which you want to get results.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventDataStore"`: The ARN (or ID suffix of the ARN) of the event data store against
which the query was run.
- `"MaxQueryResults"`: The maximum number of query results to display on a single page.
- `"NextToken"`: A token you can use to get the next page of query results.
"""
function get_query_results(QueryId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetQueryResults",
Dict{String,Any}("QueryId" => QueryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_query_results(
QueryId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetQueryResults",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("QueryId" => QueryId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource_policy(resource_arn)
get_resource_policy(resource_arn, params::Dict{String,<:Any})
Retrieves the JSON text of the resource-based policy document attached to the CloudTrail
channel.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudTrail channel attached to the
resource-based policy. The following is the format of a resource ARN:
arn:aws:cloudtrail:us-east-2:123456789012:channel/MyChannel.
"""
function get_resource_policy(ResourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetResourcePolicy",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource_policy(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"GetResourcePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_trail(name)
get_trail(name, params::Dict{String,<:Any})
Returns settings information for a specified trail.
# Arguments
- `name`: The name or the Amazon Resource Name (ARN) of the trail for which you want to
retrieve settings information.
"""
function get_trail(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetTrail",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_trail(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetTrail",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_trail_status(name)
get_trail_status(name, params::Dict{String,<:Any})
Returns a JSON-formatted list of information about the specified trail. Fields include
information on delivery errors, Amazon SNS and Amazon S3 errors, and start and stop logging
times for each trail. This operation returns trail status from a single Region. To return
trail status from all Regions, you must call the operation on each Region.
# Arguments
- `name`: Specifies the name or the CloudTrail ARN of the trail for which you are
requesting status. To get the status of a shadow trail (a replication of the trail in
another Region), you must specify its ARN. The following is the format of a trail ARN.
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
"""
function get_trail_status(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"GetTrailStatus",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_trail_status(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"GetTrailStatus",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_channels()
list_channels(params::Dict{String,<:Any})
Lists the channels in the current account, and their source names.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of CloudTrail channels to display on a single page.
- `"NextToken"`: The token to use to get the next page of results after a previous API
call. This token must be passed in with the same parameters that were specified in the
original call. For example, if the original call specified an AttributeKey of 'Username'
with a value of 'root', the call with NextToken should include those same parameters.
"""
function list_channels(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListChannels"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_channels(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListChannels", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_event_data_stores()
list_event_data_stores(params::Dict{String,<:Any})
Returns information about all event data stores in the account, in the current Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of event data stores to display on a single page.
- `"NextToken"`: A token you can use to get the next page of event data store results.
"""
function list_event_data_stores(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListEventDataStores"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_event_data_stores(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListEventDataStores",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_import_failures(import_id)
list_import_failures(import_id, params::Dict{String,<:Any})
Returns a list of failures for the specified import.
# Arguments
- `import_id`: The ID of the import.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of failures to display on a single page.
- `"NextToken"`: A token you can use to get the next page of import failures.
"""
function list_import_failures(ImportId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListImportFailures",
Dict{String,Any}("ImportId" => ImportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_import_failures(
ImportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"ListImportFailures",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ImportId" => ImportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_imports()
list_imports(params::Dict{String,<:Any})
Returns information on all imports, or a select set of imports by ImportStatus or
Destination.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Destination"`: The ARN of the destination event data store.
- `"ImportStatus"`: The status of the import.
- `"MaxResults"`: The maximum number of imports to display on a single page.
- `"NextToken"`: A token you can use to get the next page of import results.
"""
function list_imports(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail("ListImports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_imports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListImports", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_insights_metric_data(event_name, event_source, insight_type)
list_insights_metric_data(event_name, event_source, insight_type, params::Dict{String,<:Any})
Returns Insights metrics data for trails that have enabled Insights. The request must
include the EventSource, EventName, and InsightType parameters. If the InsightType is set
to ApiErrorRateInsight, the request must also include the ErrorCode parameter. The
following are the available time periods for ListInsightsMetricData. Each cutoff is
inclusive. Data points with a period of 60 seconds (1-minute) are available for 15 days.
Data points with a period of 300 seconds (5-minute) are available for 63 days. Data
points with a period of 3600 seconds (1 hour) are available for 90 days. Access to the
ListInsightsMetricData API operation is linked to the cloudtrail:LookupEvents action. To
use this operation, you must have permissions to perform the cloudtrail:LookupEvents action.
# Arguments
- `event_name`: The name of the event, typically the Amazon Web Services API on which
unusual levels of activity were recorded.
- `event_source`: The Amazon Web Services service to which the request was made, such as
iam.amazonaws.com or s3.amazonaws.com.
- `insight_type`: The type of CloudTrail Insights event, which is either ApiCallRateInsight
or ApiErrorRateInsight. The ApiCallRateInsight Insights type analyzes write-only management
API calls that are aggregated per minute against a baseline API call volume. The
ApiErrorRateInsight Insights type analyzes management API calls that result in error codes.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DataType"`: Type of datapoints to return. Valid values are NonZeroData and
FillWithZeros. The default is NonZeroData.
- `"EndTime"`: Specifies, in UTC, the end time for time-series data. The value specified is
exclusive; results include data points up to the specified time stamp. The default is the
time of request.
- `"ErrorCode"`: Conditionally required if the InsightType parameter is set to
ApiErrorRateInsight. If returning metrics for the ApiErrorRateInsight Insights type, this
is the error to retrieve data for. For example, AccessDenied.
- `"MaxResults"`: The maximum number of datapoints to return. Valid values are integers
from 1 to 21600. The default value is 21600.
- `"NextToken"`: Returned if all datapoints can't be returned in a single call. For
example, due to reaching MaxResults. Add this parameter to the request to continue
retrieving results starting from the last evaluated point.
- `"Period"`: Granularity of data to retrieve, in seconds. Valid values are 60, 300, and
3600. If you specify any other value, you will get an error. The default is 3600 seconds.
- `"StartTime"`: Specifies, in UTC, the start time for time-series data. The value
specified is inclusive; results include data points with the specified time stamp. The
default is 90 days before the time of request.
"""
function list_insights_metric_data(
EventName, EventSource, InsightType; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListInsightsMetricData",
Dict{String,Any}(
"EventName" => EventName,
"EventSource" => EventSource,
"InsightType" => InsightType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_insights_metric_data(
EventName,
EventSource,
InsightType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"ListInsightsMetricData",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EventName" => EventName,
"EventSource" => EventSource,
"InsightType" => InsightType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_public_keys()
list_public_keys(params::Dict{String,<:Any})
Returns all public keys whose private keys were used to sign the digest files within the
specified time range. The public key is needed to validate digest files that were signed
with its corresponding private key. CloudTrail uses different private and public key pairs
per Region. Each digest file is signed with a private key unique to its Region. When you
validate a digest file from a specific Region, you must look in the same Region for its
corresponding public key.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EndTime"`: Optionally specifies, in UTC, the end of the time range to look up public
keys for CloudTrail digest files. If not specified, the current time is used.
- `"NextToken"`: Reserved for future use.
- `"StartTime"`: Optionally specifies, in UTC, the start of the time range to look up
public keys for CloudTrail digest files. If not specified, the current time is used, and
the current public key is returned.
"""
function list_public_keys(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListPublicKeys"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_public_keys(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListPublicKeys", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_queries(event_data_store)
list_queries(event_data_store, params::Dict{String,<:Any})
Returns a list of queries and query statuses for the past seven days. You must specify an
ARN value for EventDataStore. Optionally, to shorten the list of results, you can specify a
time range, formatted as timestamps, by adding StartTime and EndTime parameters, and a
QueryStatus value. Valid values for QueryStatus include QUEUED, RUNNING, FINISHED, FAILED,
TIMED_OUT, or CANCELLED.
# Arguments
- `event_data_store`: The ARN (or the ID suffix of the ARN) of an event data store on which
queries were run.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EndTime"`: Use with StartTime to bound a ListQueries request, and limit its results to
only those queries run within a specified time period.
- `"MaxResults"`: The maximum number of queries to show on a page.
- `"NextToken"`: A token you can use to get the next page of results.
- `"QueryStatus"`: The status of queries that you want to return in results. Valid values
for QueryStatus include QUEUED, RUNNING, FINISHED, FAILED, TIMED_OUT, or CANCELLED.
- `"StartTime"`: Use with EndTime to bound a ListQueries request, and limit its results to
only those queries run within a specified time period.
"""
function list_queries(EventDataStore; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListQueries",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_queries(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"ListQueries",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags(resource_id_list)
list_tags(resource_id_list, params::Dict{String,<:Any})
Lists the tags for the specified trails, event data stores, or channels in the current
Region.
# Arguments
- `resource_id_list`: Specifies a list of trail, event data store, or channel ARNs whose
tags will be listed. The list has a limit of 20 ARNs. Example trail ARN format:
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail Example event data store ARN
format:
arn:aws:cloudtrail:us-east-2:123456789012:eventdatastore/EXAMPLE-f852-4e8f-8bd1-bcf6cEXAMPLE
Example channel ARN format: arn:aws:cloudtrail:us-east-2:123456789012:channel/01234567890
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: Reserved for future use.
"""
function list_tags(ResourceIdList; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"ListTags",
Dict{String,Any}("ResourceIdList" => ResourceIdList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags(
ResourceIdList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"ListTags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceIdList" => ResourceIdList), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_trails()
list_trails(params::Dict{String,<:Any})
Lists trails that are in the current account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: The token to use to get the next page of results after a previous API
call. This token must be passed in with the same parameters that were specified in the
original call. For example, if the original call specified an AttributeKey of 'Username'
with a value of 'root', the call with NextToken should include those same parameters.
"""
function list_trails(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail("ListTrails"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_trails(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"ListTrails", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
lookup_events()
lookup_events(params::Dict{String,<:Any})
Looks up management events or CloudTrail Insights events that are captured by CloudTrail.
You can look up events that occurred in a Region within the last 90 days. LookupEvents
returns recent Insights events for trails that enable Insights. To view Insights events for
an event data store, you can run queries on your Insights event data store, and you can
also view the Lake dashboard for Insights. Lookup supports the following attributes for
management events: Amazon Web Services access key Event ID Event name Event source
Read only Resource name Resource type User name Lookup supports the following
attributes for Insights events: Event ID Event name Event source All attributes are
optional. The default number of results returned is 50, with a maximum of 50 possible. The
response includes a token that you can use to get the next page of results. The rate of
lookup requests is limited to two per second, per account, per Region. If this limit is
exceeded, a throttling error occurs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EndTime"`: Specifies that only events that occur before or at the specified time are
returned. If the specified end time is before the specified start time, an error is
returned.
- `"EventCategory"`: Specifies the event category. If you do not specify an event category,
events of the category are not returned in the response. For example, if you do not specify
insight as the value of EventCategory, no Insights events are returned.
- `"LookupAttributes"`: Contains a list of lookup attributes. Currently the list can
contain only one item.
- `"MaxResults"`: The number of events to return. Possible values are 1 through 50. The
default is 50.
- `"NextToken"`: The token to use to get the next page of results after a previous API
call. This token must be passed in with the same parameters that were specified in the
original call. For example, if the original call specified an AttributeKey of 'Username'
with a value of 'root', the call with NextToken should include those same parameters.
- `"StartTime"`: Specifies that only events that occur after or at the specified time are
returned. If the specified start time is after the specified end time, an error is returned.
"""
function lookup_events(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"LookupEvents"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function lookup_events(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"LookupEvents", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_event_selectors(trail_name)
put_event_selectors(trail_name, params::Dict{String,<:Any})
Configures an event selector or advanced event selectors for your trail. Use event
selectors or advanced event selectors to specify management and data event settings for
your trail. If you want your trail to log Insights events, be sure the event selector
enables logging of the Insights event types you want configured for your trail. For more
information about logging Insights events, see Logging Insights events in the CloudTrail
User Guide. By default, trails created without specific event selectors are configured to
log all read and write management events, and no data events. When an event occurs in your
account, CloudTrail evaluates the event selectors or advanced event selectors in all
trails. For each trail, if the event matches any event selector, the trail processes and
logs the event. If the event doesn't match any event selector, the trail doesn't log the
event. Example You create an event selector for a trail and specify that you want
write-only events. The EC2 GetConsoleOutput and RunInstances API operations occur in your
account. CloudTrail evaluates whether the events match your event selectors. The
RunInstances is a write-only event and it matches your event selector. The trail logs the
event. The GetConsoleOutput is a read-only event that doesn't match your event selector.
The trail doesn't log the event. The PutEventSelectors operation must be called from the
Region in which the trail was created; otherwise, an InvalidHomeRegionException exception
is thrown. You can configure up to five event selectors for each trail. For more
information, see Logging management events, Logging data events, and Quotas in CloudTrail
in the CloudTrail User Guide. You can add advanced event selectors, and conditions for your
advanced event selectors, up to a maximum of 500 values for all conditions and selectors on
a trail. You can use either AdvancedEventSelectors or EventSelectors, but not both. If you
apply AdvancedEventSelectors to a trail, any existing EventSelectors are overwritten. For
more information about advanced event selectors, see Logging data events in the CloudTrail
User Guide.
# Arguments
- `trail_name`: Specifies the name of the trail or trail ARN. If you specify a trail name,
the string must meet the following requirements: Contain only ASCII letters (a-z, A-Z),
numbers (0-9), periods (.), underscores (_), or dashes (-) Start with a letter or number,
and end with a letter or number Be between 3 and 128 characters Have no adjacent
periods, underscores or dashes. Names like my-_namespace and my--namespace are not valid.
Not be in IP address format (for example, 192.168.5.4) If you specify a trail ARN, it
must be in the following format. arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdvancedEventSelectors"`: Specifies the settings for advanced event selectors. You can
add advanced event selectors, and conditions for your advanced event selectors, up to a
maximum of 500 values for all conditions and selectors on a trail. You can use either
AdvancedEventSelectors or EventSelectors, but not both. If you apply AdvancedEventSelectors
to a trail, any existing EventSelectors are overwritten. For more information about
advanced event selectors, see Logging data events in the CloudTrail User Guide.
- `"EventSelectors"`: Specifies the settings for your event selectors. You can configure up
to five event selectors for a trail. You can use either EventSelectors or
AdvancedEventSelectors in a PutEventSelectors request, but not both. If you apply
EventSelectors to a trail, any existing AdvancedEventSelectors are overwritten.
"""
function put_event_selectors(TrailName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"PutEventSelectors",
Dict{String,Any}("TrailName" => TrailName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_event_selectors(
TrailName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"PutEventSelectors",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TrailName" => TrailName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_insight_selectors(insight_selectors)
put_insight_selectors(insight_selectors, params::Dict{String,<:Any})
Lets you enable Insights event logging by specifying the Insights selectors that you want
to enable on an existing trail or event data store. You also use PutInsightSelectors to
turn off Insights event logging, by passing an empty list of Insights types. The valid
Insights event types are ApiErrorRateInsight and ApiCallRateInsight. To enable Insights on
an event data store, you must specify the ARNs (or ID suffix of the ARNs) for the source
event data store (EventDataStore) and the destination event data store
(InsightsDestination). The source event data store logs management events and enables
Insights. The destination event data store logs Insights events based upon the management
event activity of the source event data store. The source and destination event data stores
must belong to the same Amazon Web Services account. To log Insights events for a trail,
you must specify the name (TrailName) of the CloudTrail trail for which you want to change
or add Insights selectors. To log CloudTrail Insights events on API call volume, the trail
or event data store must log write management events. To log CloudTrail Insights events on
API error rate, the trail or event data store must log read or write management events. You
can call GetEventSelectors on a trail to check whether the trail logs management events.
You can call GetEventDataStore on an event data store to check whether the event data store
logs management events. For more information, see Logging CloudTrail Insights events in the
CloudTrail User Guide.
# Arguments
- `insight_selectors`: A JSON string that contains the Insights types you want to log on a
trail or event data store. ApiCallRateInsight and ApiErrorRateInsight are valid Insight
types. The ApiCallRateInsight Insights type analyzes write-only management API calls that
are aggregated per minute against a baseline API call volume. The ApiErrorRateInsight
Insights type analyzes management API calls that result in error codes. The error is shown
if the API call is unsuccessful.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventDataStore"`: The ARN (or ID suffix of the ARN) of the source event data store for
which you want to change or add Insights selectors. To enable Insights on an event data
store, you must provide both the EventDataStore and InsightsDestination parameters. You
cannot use this parameter with the TrailName parameter.
- `"InsightsDestination"`: The ARN (or ID suffix of the ARN) of the destination event data
store that logs Insights events. To enable Insights on an event data store, you must
provide both the EventDataStore and InsightsDestination parameters. You cannot use this
parameter with the TrailName parameter.
- `"TrailName"`: The name of the CloudTrail trail for which you want to change or add
Insights selectors. You cannot use this parameter with the EventDataStore and
InsightsDestination parameters.
"""
function put_insight_selectors(
InsightSelectors; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"PutInsightSelectors",
Dict{String,Any}("InsightSelectors" => InsightSelectors);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_insight_selectors(
InsightSelectors,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"PutInsightSelectors",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("InsightSelectors" => InsightSelectors), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_resource_policy(resource_arn, resource_policy)
put_resource_policy(resource_arn, resource_policy, params::Dict{String,<:Any})
Attaches a resource-based permission policy to a CloudTrail channel that is used for an
integration with an event source outside of Amazon Web Services. For more information about
resource-based policies, see CloudTrail resource-based policy examples in the CloudTrail
User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the CloudTrail channel attached to the
resource-based policy. The following is the format of a resource ARN:
arn:aws:cloudtrail:us-east-2:123456789012:channel/MyChannel.
- `resource_policy`: A JSON-formatted string for an Amazon Web Services resource-based
policy. The following are requirements for the resource policy: Contains only one
action: cloudtrail-data:PutAuditEvents Contains at least one statement. The policy can
have a maximum of 20 statements. Each statement contains at least one principal. A
statement can have a maximum of 50 principals.
"""
function put_resource_policy(
ResourceArn, ResourcePolicy; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"PutResourcePolicy",
Dict{String,Any}("ResourceArn" => ResourceArn, "ResourcePolicy" => ResourcePolicy);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_resource_policy(
ResourceArn,
ResourcePolicy,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"PutResourcePolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ResourceArn" => ResourceArn, "ResourcePolicy" => ResourcePolicy
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_organization_delegated_admin(member_account_id)
register_organization_delegated_admin(member_account_id, params::Dict{String,<:Any})
Registers an organization’s member account as the CloudTrail delegated administrator.
# Arguments
- `member_account_id`: An organization member account ID that you want to designate as a
delegated administrator.
"""
function register_organization_delegated_admin(
MemberAccountId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"RegisterOrganizationDelegatedAdmin",
Dict{String,Any}("MemberAccountId" => MemberAccountId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_organization_delegated_admin(
MemberAccountId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"RegisterOrganizationDelegatedAdmin",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("MemberAccountId" => MemberAccountId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_tags(resource_id, tags_list)
remove_tags(resource_id, tags_list, params::Dict{String,<:Any})
Removes the specified tags from a trail, event data store, or channel.
# Arguments
- `resource_id`: Specifies the ARN of the trail, event data store, or channel from which
tags should be removed. Example trail ARN format:
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail Example event data store ARN
format:
arn:aws:cloudtrail:us-east-2:123456789012:eventdatastore/EXAMPLE-f852-4e8f-8bd1-bcf6cEXAMPLE
Example channel ARN format: arn:aws:cloudtrail:us-east-2:123456789012:channel/01234567890
- `tags_list`: Specifies a list of tags to be removed.
"""
function remove_tags(
ResourceId, TagsList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"RemoveTags",
Dict{String,Any}("ResourceId" => ResourceId, "TagsList" => TagsList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_tags(
ResourceId,
TagsList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"RemoveTags",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceId" => ResourceId, "TagsList" => TagsList),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
restore_event_data_store(event_data_store)
restore_event_data_store(event_data_store, params::Dict{String,<:Any})
Restores a deleted event data store specified by EventDataStore, which accepts an event
data store ARN. You can only restore a deleted event data store within the seven-day wait
period after deletion. Restoring an event data store can take several minutes, depending on
the size of the event data store.
# Arguments
- `event_data_store`: The ARN (or the ID suffix of the ARN) of the event data store that
you want to restore.
"""
function restore_event_data_store(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"RestoreEventDataStore",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function restore_event_data_store(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"RestoreEventDataStore",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_event_data_store_ingestion(event_data_store)
start_event_data_store_ingestion(event_data_store, params::Dict{String,<:Any})
Starts the ingestion of live events on an event data store specified as either an ARN or
the ID portion of the ARN. To start ingestion, the event data store Status must be
STOPPED_INGESTION and the eventCategory must be Management, Data, or ConfigurationItem.
# Arguments
- `event_data_store`: The ARN (or ID suffix of the ARN) of the event data store for which
you want to start ingestion.
"""
function start_event_data_store_ingestion(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StartEventDataStoreIngestion",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_event_data_store_ingestion(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"StartEventDataStoreIngestion",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_import()
start_import(params::Dict{String,<:Any})
Starts an import of logged trail events from a source S3 bucket to a destination event
data store. By default, CloudTrail only imports events contained in the S3 bucket's
CloudTrail prefix and the prefixes inside the CloudTrail prefix, and does not check
prefixes for other Amazon Web Services services. If you want to import CloudTrail events
contained in another prefix, you must include the prefix in the S3LocationUri. For more
considerations about importing trail events, see Considerations for copying trail events in
the CloudTrail User Guide. When you start a new import, the Destinations and ImportSource
parameters are required. Before starting a new import, disable any access control lists
(ACLs) attached to the source S3 bucket. For more information about disabling ACLs, see
Controlling ownership of objects and disabling ACLs for your bucket. When you retry an
import, the ImportID parameter is required. If the destination event data store is for
an organization, you must use the management account to import trail events. You cannot use
the delegated administrator account for the organization.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Destinations"`: The ARN of the destination event data store. Use this parameter for a
new import.
- `"EndEventTime"`: Use with StartEventTime to bound a StartImport request, and limit
imported trail events to only those events logged within a specified time period. When you
specify a time range, CloudTrail checks the prefix and log file names to verify the names
contain a date between the specified StartEventTime and EndEventTime before attempting to
import events.
- `"ImportId"`: The ID of the import. Use this parameter when you are retrying an import.
- `"ImportSource"`: The source S3 bucket for the import. Use this parameter for a new
import.
- `"StartEventTime"`: Use with EndEventTime to bound a StartImport request, and limit
imported trail events to only those events logged within a specified time period. When you
specify a time range, CloudTrail checks the prefix and log file names to verify the names
contain a date between the specified StartEventTime and EndEventTime before attempting to
import events.
"""
function start_import(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail("StartImport"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function start_import(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StartImport", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
start_logging(name)
start_logging(name, params::Dict{String,<:Any})
Starts the recording of Amazon Web Services API calls and log file delivery for a trail.
For a trail that is enabled in all Regions, this operation must be called from the Region
in which the trail was created. This operation cannot be called on the shadow trails
(replicated trails in other Regions) of a trail that is enabled in all Regions.
# Arguments
- `name`: Specifies the name or the CloudTrail ARN of the trail for which CloudTrail logs
Amazon Web Services API calls. The following is the format of a trail ARN.
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
"""
function start_logging(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"StartLogging",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_logging(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StartLogging",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_query()
start_query(params::Dict{String,<:Any})
Starts a CloudTrail Lake query. Use the QueryStatement parameter to provide your SQL query,
enclosed in single quotation marks. Use the optional DeliveryS3Uri parameter to deliver the
query results to an S3 bucket. StartQuery requires you specify either the QueryStatement
parameter, or a QueryAlias and any QueryParameters. In the current release, the QueryAlias
and QueryParameters parameters are used only for the queries that populate the CloudTrail
Lake dashboards.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DeliveryS3Uri"`: The URI for the S3 bucket where CloudTrail delivers the query
results.
- `"QueryAlias"`: The alias that identifies a query template.
- `"QueryParameters"`: The query parameters for the specified QueryAlias.
- `"QueryStatement"`: The SQL code of your query.
"""
function start_query(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail("StartQuery"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function start_query(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StartQuery", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
stop_event_data_store_ingestion(event_data_store)
stop_event_data_store_ingestion(event_data_store, params::Dict{String,<:Any})
Stops the ingestion of live events on an event data store specified as either an ARN or the
ID portion of the ARN. To stop ingestion, the event data store Status must be ENABLED and
the eventCategory must be Management, Data, or ConfigurationItem.
# Arguments
- `event_data_store`: The ARN (or ID suffix of the ARN) of the event data store for which
you want to stop ingestion.
"""
function stop_event_data_store_ingestion(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StopEventDataStoreIngestion",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_event_data_store_ingestion(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"StopEventDataStoreIngestion",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_import(import_id)
stop_import(import_id, params::Dict{String,<:Any})
Stops a specified import.
# Arguments
- `import_id`: The ID of the import.
"""
function stop_import(ImportId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"StopImport",
Dict{String,Any}("ImportId" => ImportId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_import(
ImportId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"StopImport",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ImportId" => ImportId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_logging(name)
stop_logging(name, params::Dict{String,<:Any})
Suspends the recording of Amazon Web Services API calls and log file delivery for the
specified trail. Under most circumstances, there is no need to use this action. You can
update a trail without stopping it first. This action is the only way to stop recording.
For a trail enabled in all Regions, this operation must be called from the Region in which
the trail was created, or an InvalidHomeRegionException will occur. This operation cannot
be called on the shadow trails (replicated trails in other Regions) of a trail enabled in
all Regions.
# Arguments
- `name`: Specifies the name or the CloudTrail ARN of the trail for which CloudTrail will
stop logging Amazon Web Services API calls. The following is the format of a trail ARN.
arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
"""
function stop_logging(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"StopLogging",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_logging(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"StopLogging",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_channel(channel)
update_channel(channel, params::Dict{String,<:Any})
Updates a channel specified by a required channel ARN or UUID.
# Arguments
- `channel`: The ARN or ID (the ARN suffix) of the channel that you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Destinations"`: The ARNs of event data stores that you want to log events arriving
through the channel.
- `"Name"`: Changes the name of the channel.
"""
function update_channel(Channel; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"UpdateChannel",
Dict{String,Any}("Channel" => Channel);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_channel(
Channel, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"UpdateChannel",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Channel" => Channel), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_event_data_store(event_data_store)
update_event_data_store(event_data_store, params::Dict{String,<:Any})
Updates an event data store. The required EventDataStore value is an ARN or the ID portion
of the ARN. Other parameters are optional, but at least one optional parameter must be
specified, or CloudTrail throws an error. RetentionPeriod is in days, and valid values are
integers between 7 and 3653 if the BillingMode is set to EXTENDABLE_RETENTION_PRICING, or
between 7 and 2557 if BillingMode is set to FIXED_RETENTION_PRICING. By default,
TerminationProtection is enabled. For event data stores for CloudTrail events,
AdvancedEventSelectors includes or excludes management or data events in your event data
store. For more information about AdvancedEventSelectors, see AdvancedEventSelectors. For
event data stores for CloudTrail Insights events, Config configuration items, Audit Manager
evidence, or non-Amazon Web Services events, AdvancedEventSelectors includes events of that
type in your event data store.
# Arguments
- `event_data_store`: The ARN (or the ID suffix of the ARN) of the event data store that
you want to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdvancedEventSelectors"`: The advanced event selectors used to select events for the
event data store. You can configure up to five advanced event selectors for each event data
store.
- `"BillingMode"`: You can't change the billing mode from EXTENDABLE_RETENTION_PRICING to
FIXED_RETENTION_PRICING. If BillingMode is set to EXTENDABLE_RETENTION_PRICING and you want
to use FIXED_RETENTION_PRICING instead, you'll need to stop ingestion on the event data
store and create a new event data store that uses FIXED_RETENTION_PRICING. The billing
mode for the event data store determines the cost for ingesting events and the default and
maximum retention period for the event data store. The following are the possible values:
EXTENDABLE_RETENTION_PRICING - This billing mode is generally recommended if you want a
flexible retention period of up to 3653 days (about 10 years). The default retention period
for this billing mode is 366 days. FIXED_RETENTION_PRICING - This billing mode is
recommended if you expect to ingest more than 25 TB of event data per month and need a
retention period of up to 2557 days (about 7 years). The default retention period for this
billing mode is 2557 days. For more information about CloudTrail pricing, see CloudTrail
Pricing and Managing CloudTrail Lake costs.
- `"KmsKeyId"`: Specifies the KMS key ID to use to encrypt the events delivered by
CloudTrail. The value can be an alias name prefixed by alias/, a fully specified ARN to an
alias, a fully specified ARN to a key, or a globally unique identifier. Disabling or
deleting the KMS key, or removing CloudTrail permissions on the key, prevents CloudTrail
from logging events to the event data store, and prevents users from querying the data in
the event data store that was encrypted with the key. After you associate an event data
store with a KMS key, the KMS key cannot be removed or changed. Before you disable or
delete a KMS key that you are using with an event data store, delete or back up your event
data store. CloudTrail also supports KMS multi-Region keys. For more information about
multi-Region keys, see Using multi-Region keys in the Key Management Service Developer
Guide. Examples: alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:key/12345678-1234-1234-1234-123456789012
12345678-1234-1234-1234-123456789012
- `"MultiRegionEnabled"`: Specifies whether an event data store collects events from all
Regions, or only from the Region in which it was created.
- `"Name"`: The event data store name.
- `"OrganizationEnabled"`: Specifies whether an event data store collects events logged for
an organization in Organizations. Only the management account for the organization can
convert an organization event data store to a non-organization event data store, or convert
a non-organization event data store to an organization event data store.
- `"RetentionPeriod"`: The retention period of the event data store, in days. If
BillingMode is set to EXTENDABLE_RETENTION_PRICING, you can set a retention period of up to
3653 days, the equivalent of 10 years. If BillingMode is set to FIXED_RETENTION_PRICING,
you can set a retention period of up to 2557 days, the equivalent of seven years.
CloudTrail Lake determines whether to retain an event by checking if the eventTime of the
event is within the specified retention period. For example, if you set a retention period
of 90 days, CloudTrail will remove events when the eventTime is older than 90 days. If you
decrease the retention period of an event data store, CloudTrail will remove any events
with an eventTime older than the new retention period. For example, if the previous
retention period was 365 days and you decrease it to 100 days, CloudTrail will remove
events with an eventTime older than 100 days.
- `"TerminationProtectionEnabled"`: Indicates that termination protection is enabled and
the event data store cannot be automatically deleted.
"""
function update_event_data_store(
EventDataStore; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"UpdateEventDataStore",
Dict{String,Any}("EventDataStore" => EventDataStore);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_event_data_store(
EventDataStore,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail(
"UpdateEventDataStore",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("EventDataStore" => EventDataStore), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_trail(name)
update_trail(name, params::Dict{String,<:Any})
Updates trail settings that control what events you are logging, and how to handle log
files. Changes to a trail do not require stopping the CloudTrail service. Use this action
to designate an existing bucket for log delivery. If the existing bucket has previously
been a target for CloudTrail log files, an IAM policy exists for the bucket. UpdateTrail
must be called from the Region in which the trail was created; otherwise, an
InvalidHomeRegionException is thrown.
# Arguments
- `name`: Specifies the name of the trail or trail ARN. If Name is a trail name, the string
must meet the following requirements: Contain only ASCII letters (a-z, A-Z), numbers
(0-9), periods (.), underscores (_), or dashes (-) Start with a letter or number, and end
with a letter or number Be between 3 and 128 characters Have no adjacent periods,
underscores or dashes. Names like my-_namespace and my--namespace are not valid. Not be
in IP address format (for example, 192.168.5.4) If Name is a trail ARN, it must be in the
following format. arn:aws:cloudtrail:us-east-2:123456789012:trail/MyTrail
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CloudWatchLogsLogGroupArn"`: Specifies a log group name using an Amazon Resource Name
(ARN), a unique identifier that represents the log group to which CloudTrail logs are
delivered. You must use a log group that exists in your account. Not required unless you
specify CloudWatchLogsRoleArn.
- `"CloudWatchLogsRoleArn"`: Specifies the role for the CloudWatch Logs endpoint to assume
to write to a user's log group. You must use a role that exists in your account.
- `"EnableLogFileValidation"`: Specifies whether log file validation is enabled. The
default is false. When you disable log file integrity validation, the chain of digest
files is broken after one hour. CloudTrail does not create digest files for log files that
were delivered during a period in which log file integrity validation was disabled. For
example, if you enable log file integrity validation at noon on January 1, disable it at
noon on January 2, and re-enable it at noon on January 10, digest files will not be created
for the log files delivered from noon on January 2 to noon on January 10. The same applies
whenever you stop CloudTrail logging or delete a trail.
- `"IncludeGlobalServiceEvents"`: Specifies whether the trail is publishing events from
global services such as IAM to the log files.
- `"IsMultiRegionTrail"`: Specifies whether the trail applies only to the current Region or
to all Regions. The default is false. If the trail exists only in the current Region and
this value is set to true, shadow trails (replications of the trail) will be created in the
other Regions. If the trail exists in all Regions and this value is set to false, the trail
will remain in the Region where it was created, and its shadow trails in other Regions will
be deleted. As a best practice, consider using trails that log events in all Regions.
- `"IsOrganizationTrail"`: Specifies whether the trail is applied to all accounts in an
organization in Organizations, or only for the current Amazon Web Services account. The
default is false, and cannot be true unless the call is made on behalf of an Amazon Web
Services account that is the management account for an organization in Organizations. If
the trail is not an organization trail and this is set to true, the trail will be created
in all Amazon Web Services accounts that belong to the organization. If the trail is an
organization trail and this is set to false, the trail will remain in the current Amazon
Web Services account but be deleted from all member accounts in the organization. Only the
management account for the organization can convert an organization trail to a
non-organization trail, or convert a non-organization trail to an organization trail.
- `"KmsKeyId"`: Specifies the KMS key ID to use to encrypt the logs delivered by
CloudTrail. The value can be an alias name prefixed by \"alias/\", a fully specified ARN to
an alias, a fully specified ARN to a key, or a globally unique identifier. CloudTrail also
supports KMS multi-Region keys. For more information about multi-Region keys, see Using
multi-Region keys in the Key Management Service Developer Guide. Examples:
alias/MyAliasName arn:aws:kms:us-east-2:123456789012:alias/MyAliasName
arn:aws:kms:us-east-2:123456789012:key/12345678-1234-1234-1234-123456789012
12345678-1234-1234-1234-123456789012
- `"S3BucketName"`: Specifies the name of the Amazon S3 bucket designated for publishing
log files. See Amazon S3 Bucket naming rules.
- `"S3KeyPrefix"`: Specifies the Amazon S3 key prefix that comes after the name of the
bucket you have designated for log file delivery. For more information, see Finding Your
CloudTrail Log Files. The maximum length is 200 characters.
- `"SnsTopicName"`: Specifies the name of the Amazon SNS topic defined for notification of
log file delivery. The maximum length is 256 characters.
"""
function update_trail(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudtrail(
"UpdateTrail",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_trail(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail(
"UpdateTrail",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 1906 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudtrail_data
using AWS.Compat
using AWS.UUIDs
"""
put_audit_events(audit_events, channel_arn)
put_audit_events(audit_events, channel_arn, params::Dict{String,<:Any})
Ingests your application events into CloudTrail Lake. A required parameter, auditEvents,
accepts the JSON records (also called payload) of events that you want CloudTrail to
ingest. You can add up to 100 of these events (or up to 1 MB) per PutAuditEvents request.
# Arguments
- `audit_events`: The JSON payload of events that you want to ingest. You can also point to
the JSON event payload in a file.
- `channel_arn`: The ARN or ID (the ARN suffix) of a channel.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"externalId"`: A unique identifier that is conditionally required when the channel's
resource policy includes an external ID. This value can be any string, such as a passphrase
or account number.
"""
function put_audit_events(
auditEvents, channelArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudtrail_data(
"POST",
"/PutAuditEvents",
Dict{String,Any}("auditEvents" => auditEvents, "channelArn" => channelArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_audit_events(
auditEvents,
channelArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudtrail_data(
"POST",
"/PutAuditEvents",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("auditEvents" => auditEvents, "channelArn" => channelArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 111424 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudwatch
using AWS.Compat
using AWS.UUIDs
"""
delete_alarms(alarm_names)
delete_alarms(alarm_names, params::Dict{String,<:Any})
Deletes the specified alarms. You can delete up to 100 alarms in one operation. However,
this total can include no more than one composite alarm. For example, you could delete 99
metric alarms and one composite alarms with one operation, but you can't delete two
composite alarms with one operation. If you specify an incorrect alarm name or make any
other error in the operation, no alarms are deleted. To confirm that alarms were deleted
successfully, you can use the DescribeAlarms operation after using DeleteAlarms. It is
possible to create a loop or cycle of composite alarms, where composite alarm A depends on
composite alarm B, and composite alarm B also depends on composite alarm A. In this
scenario, you can't delete any composite alarm that is part of the cycle because there is
always still a composite alarm that depends on that alarm that you want to delete. To get
out of such a situation, you must break the cycle by changing the rule of one of the
composite alarms in the cycle to remove a dependency that creates the cycle. The simplest
change to make to break a cycle is to change the AlarmRule of one of the alarms to false.
Additionally, the evaluation of composite alarms stops if CloudWatch detects a cycle in the
evaluation path.
# Arguments
- `alarm_names`: The alarms to be deleted. Do not enclose the alarm names in quote marks.
"""
function delete_alarms(AlarmNames; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DeleteAlarms",
Dict{String,Any}("AlarmNames" => AlarmNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_alarms(
AlarmNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DeleteAlarms",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AlarmNames" => AlarmNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_anomaly_detector()
delete_anomaly_detector(params::Dict{String,<:Any})
Deletes the specified anomaly detection model from your account. For more information
about how to delete an anomaly detection model, see Deleting an anomaly detection model in
the CloudWatch User Guide.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Dimensions"`: The metric dimensions associated with the anomaly detection model to
delete.
- `"MetricMathAnomalyDetector"`: The metric math anomaly detector to be deleted. When using
MetricMathAnomalyDetector, you cannot include following parameters in the same operation:
Dimensions, MetricName Namespace Stat the SingleMetricAnomalyDetector
parameters of DeleteAnomalyDetectorInput Instead, specify the metric math anomaly
detector attributes as part of the MetricMathAnomalyDetector property.
- `"MetricName"`: The metric name associated with the anomaly detection model to delete.
- `"Namespace"`: The namespace associated with the anomaly detection model to delete.
- `"SingleMetricAnomalyDetector"`: A single metric anomaly detector to be deleted. When
using SingleMetricAnomalyDetector, you cannot include the following parameters in the same
operation: Dimensions, MetricName Namespace Stat the
MetricMathAnomalyDetector parameters of DeleteAnomalyDetectorInput Instead, specify the
single metric anomaly detector attributes as part of the SingleMetricAnomalyDetector
property.
- `"Stat"`: The statistic associated with the anomaly detection model to delete.
"""
function delete_anomaly_detector(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DeleteAnomalyDetector"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function delete_anomaly_detector(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DeleteAnomalyDetector",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_dashboards(dashboard_names)
delete_dashboards(dashboard_names, params::Dict{String,<:Any})
Deletes all dashboards that you specify. You can specify up to 100 dashboards to delete. If
there is an error during this call, no dashboards are deleted.
# Arguments
- `dashboard_names`: The dashboards to be deleted. This parameter is required.
"""
function delete_dashboards(
DashboardNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DeleteDashboards",
Dict{String,Any}("DashboardNames" => DashboardNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_dashboards(
DashboardNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DeleteDashboards",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DashboardNames" => DashboardNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_insight_rules(rule_names)
delete_insight_rules(rule_names, params::Dict{String,<:Any})
Permanently deletes the specified Contributor Insights rules. If you create a rule, delete
it, and then re-create it with the same name, historical data from the first time the rule
was created might not be available.
# Arguments
- `rule_names`: An array of the rule names to delete. If you need to find out the names of
your rules, use DescribeInsightRules.
"""
function delete_insight_rules(RuleNames; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DeleteInsightRules",
Dict{String,Any}("RuleNames" => RuleNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_insight_rules(
RuleNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DeleteInsightRules",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RuleNames" => RuleNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_metric_stream(name)
delete_metric_stream(name, params::Dict{String,<:Any})
Permanently deletes the metric stream that you specify.
# Arguments
- `name`: The name of the metric stream to delete.
"""
function delete_metric_stream(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DeleteMetricStream",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_metric_stream(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DeleteMetricStream",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_alarm_history()
describe_alarm_history(params::Dict{String,<:Any})
Retrieves the history for the specified alarm. You can filter the results by date range or
item type. If an alarm name is not specified, the histories for either all metric alarms or
all composite alarms are returned. CloudWatch retains the history of an alarm even if you
delete the alarm. To use this operation and return information about a composite alarm, you
must be signed on with the cloudwatch:DescribeAlarmHistory permission that is scoped to *.
You can't return information about composite alarms if your cloudwatch:DescribeAlarmHistory
permission has a narrower scope.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AlarmName"`: The name of the alarm.
- `"AlarmTypes"`: Use this parameter to specify whether you want the operation to return
metric alarms or composite alarms. If you omit this parameter, only metric alarms are
returned.
- `"EndDate"`: The ending date to retrieve alarm history.
- `"HistoryItemType"`: The type of alarm histories to retrieve.
- `"MaxRecords"`: The maximum number of alarm history records to retrieve.
- `"NextToken"`: The token returned by a previous call to indicate that there is more data
available.
- `"ScanBy"`: Specified whether to return the newest or oldest alarm history first. Specify
TimestampDescending to have the newest event history returned first, and specify
TimestampAscending to have the oldest history returned first.
- `"StartDate"`: The starting date to retrieve alarm history.
"""
function describe_alarm_history(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DescribeAlarmHistory"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_alarm_history(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DescribeAlarmHistory",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_alarms()
describe_alarms(params::Dict{String,<:Any})
Retrieves the specified alarms. You can filter the results by specifying a prefix for the
alarm name, the alarm state, or a prefix for any action. To use this operation and return
information about composite alarms, you must be signed on with the
cloudwatch:DescribeAlarms permission that is scoped to *. You can't return information
about composite alarms if your cloudwatch:DescribeAlarms permission has a narrower scope.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ActionPrefix"`: Use this parameter to filter the results of the operation to only those
alarms that use a certain alarm action. For example, you could specify the ARN of an SNS
topic to find all alarms that send notifications to that topic.
- `"AlarmNamePrefix"`: An alarm name prefix. If you specify this parameter, you receive
information about all alarms that have names that start with this prefix. If this parameter
is specified, you cannot specify AlarmNames.
- `"AlarmNames"`: The names of the alarms to retrieve information about.
- `"AlarmTypes"`: Use this parameter to specify whether you want the operation to return
metric alarms or composite alarms. If you omit this parameter, only metric alarms are
returned, even if composite alarms exist in the account. For example, if you omit this
parameter or specify MetricAlarms, the operation returns only a list of metric alarms. It
does not return any composite alarms, even if composite alarms exist in the account. If you
specify CompositeAlarms, the operation returns only a list of composite alarms, and does
not return any metric alarms.
- `"ChildrenOfAlarmName"`: If you use this parameter and specify the name of a composite
alarm, the operation returns information about the \"children\" alarms of the alarm you
specify. These are the metric alarms and composite alarms referenced in the AlarmRule field
of the composite alarm that you specify in ChildrenOfAlarmName. Information about the
composite alarm that you name in ChildrenOfAlarmName is not returned. If you specify
ChildrenOfAlarmName, you cannot specify any other parameters in the request except for
MaxRecords and NextToken. If you do so, you receive a validation error. Only the Alarm
Name, ARN, StateValue (OK/ALARM/INSUFFICIENT_DATA), and StateUpdatedTimestamp information
are returned by this operation when you use this parameter. To get complete information
about these alarms, perform another DescribeAlarms operation and specify the parent alarm
names in the AlarmNames parameter.
- `"MaxRecords"`: The maximum number of alarm descriptions to retrieve.
- `"NextToken"`: The token returned by a previous call to indicate that there is more data
available.
- `"ParentsOfAlarmName"`: If you use this parameter and specify the name of a metric or
composite alarm, the operation returns information about the \"parent\" alarms of the alarm
you specify. These are the composite alarms that have AlarmRule parameters that reference
the alarm named in ParentsOfAlarmName. Information about the alarm that you specify in
ParentsOfAlarmName is not returned. If you specify ParentsOfAlarmName, you cannot specify
any other parameters in the request except for MaxRecords and NextToken. If you do so, you
receive a validation error. Only the Alarm Name and ARN are returned by this operation
when you use this parameter. To get complete information about these alarms, perform
another DescribeAlarms operation and specify the parent alarm names in the AlarmNames
parameter.
- `"StateValue"`: Specify this parameter to receive information only about alarms that are
currently in the state that you specify.
"""
function describe_alarms(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DescribeAlarms"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_alarms(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DescribeAlarms", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_alarms_for_metric(metric_name, namespace)
describe_alarms_for_metric(metric_name, namespace, params::Dict{String,<:Any})
Retrieves the alarms for the specified metric. To filter the results, specify a statistic,
period, or unit. This operation retrieves only standard alarms that are based on the
specified metric. It does not return alarms based on math expressions that use the
specified metric, or composite alarms that use the specified metric.
# Arguments
- `metric_name`: The name of the metric.
- `namespace`: The namespace of the metric.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Dimensions"`: The dimensions associated with the metric. If the metric has any
associated dimensions, you must specify them in order for the call to succeed.
- `"ExtendedStatistic"`: The percentile statistic for the metric. Specify a value between
p0.0 and p100.
- `"Period"`: The period, in seconds, over which the statistic is applied.
- `"Statistic"`: The statistic for the metric, other than percentiles. For percentile
statistics, use ExtendedStatistics.
- `"Unit"`: The unit for the metric.
"""
function describe_alarms_for_metric(
MetricName, Namespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DescribeAlarmsForMetric",
Dict{String,Any}("MetricName" => MetricName, "Namespace" => Namespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_alarms_for_metric(
MetricName,
Namespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DescribeAlarmsForMetric",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("MetricName" => MetricName, "Namespace" => Namespace),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_anomaly_detectors()
describe_anomaly_detectors(params::Dict{String,<:Any})
Lists the anomaly detection models that you have created in your account. For single metric
anomaly detectors, you can list all of the models in your account or filter the results to
only the models that are related to a certain namespace, metric name, or metric dimension.
For metric math anomaly detectors, you can list them by adding METRIC_MATH to the
AnomalyDetectorTypes array. This will return all metric math anomaly detectors in your
account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AnomalyDetectorTypes"`: The anomaly detector types to request when using
DescribeAnomalyDetectorsInput. If empty, defaults to SINGLE_METRIC.
- `"Dimensions"`: Limits the results to only the anomaly detection models that are
associated with the specified metric dimensions. If there are multiple metrics that have
these dimensions and have anomaly detection models associated, they're all returned.
- `"MaxResults"`: The maximum number of results to return in one operation. The maximum
value that you can specify is 100. To retrieve the remaining results, make another call
with the returned NextToken value.
- `"MetricName"`: Limits the results to only the anomaly detection models that are
associated with the specified metric name. If there are multiple metrics with this name in
different namespaces that have anomaly detection models, they're all returned.
- `"Namespace"`: Limits the results to only the anomaly detection models that are
associated with the specified namespace.
- `"NextToken"`: Use the token returned by the previous operation to request the next page
of results.
"""
function describe_anomaly_detectors(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DescribeAnomalyDetectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_anomaly_detectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DescribeAnomalyDetectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_insight_rules()
describe_insight_rules(params::Dict{String,<:Any})
Returns a list of all the Contributor Insights rules in your account. For more information
about Contributor Insights, see Using Contributor Insights to Analyze High-Cardinality Data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default of 500 is used.
- `"NextToken"`: Include this value, if it was returned by the previous operation, to get
the next set of rules.
"""
function describe_insight_rules(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DescribeInsightRules"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_insight_rules(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DescribeInsightRules",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_alarm_actions(alarm_names)
disable_alarm_actions(alarm_names, params::Dict{String,<:Any})
Disables the actions for the specified alarms. When an alarm's actions are disabled, the
alarm actions do not execute when the alarm state changes.
# Arguments
- `alarm_names`: The names of the alarms.
"""
function disable_alarm_actions(
AlarmNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"DisableAlarmActions",
Dict{String,Any}("AlarmNames" => AlarmNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_alarm_actions(
AlarmNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DisableAlarmActions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AlarmNames" => AlarmNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_insight_rules(rule_names)
disable_insight_rules(rule_names, params::Dict{String,<:Any})
Disables the specified Contributor Insights rules. When rules are disabled, they do not
analyze log groups and do not incur costs.
# Arguments
- `rule_names`: An array of the rule names to disable. If you need to find out the names of
your rules, use DescribeInsightRules.
"""
function disable_insight_rules(RuleNames; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"DisableInsightRules",
Dict{String,Any}("RuleNames" => RuleNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_insight_rules(
RuleNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"DisableInsightRules",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RuleNames" => RuleNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_alarm_actions(alarm_names)
enable_alarm_actions(alarm_names, params::Dict{String,<:Any})
Enables the actions for the specified alarms.
# Arguments
- `alarm_names`: The names of the alarms.
"""
function enable_alarm_actions(AlarmNames; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"EnableAlarmActions",
Dict{String,Any}("AlarmNames" => AlarmNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_alarm_actions(
AlarmNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"EnableAlarmActions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("AlarmNames" => AlarmNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_insight_rules(rule_names)
enable_insight_rules(rule_names, params::Dict{String,<:Any})
Enables the specified Contributor Insights rules. When rules are enabled, they immediately
begin analyzing log data.
# Arguments
- `rule_names`: An array of the rule names to enable. If you need to find out the names of
your rules, use DescribeInsightRules.
"""
function enable_insight_rules(RuleNames; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"EnableInsightRules",
Dict{String,Any}("RuleNames" => RuleNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_insight_rules(
RuleNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"EnableInsightRules",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("RuleNames" => RuleNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_dashboard(dashboard_name)
get_dashboard(dashboard_name, params::Dict{String,<:Any})
Displays the details of the dashboard that you specify. To copy an existing dashboard, use
GetDashboard, and then use the data returned within DashboardBody as the template for the
new dashboard when you call PutDashboard to create the copy.
# Arguments
- `dashboard_name`: The name of the dashboard to be described.
"""
function get_dashboard(DashboardName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"GetDashboard",
Dict{String,Any}("DashboardName" => DashboardName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_dashboard(
DashboardName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetDashboard",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("DashboardName" => DashboardName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_insight_rule_report(end_time, period, rule_name, start_time)
get_insight_rule_report(end_time, period, rule_name, start_time, params::Dict{String,<:Any})
This operation returns the time series data collected by a Contributor Insights rule. The
data includes the identity and number of contributors to the log group. You can also
optionally return one or more statistics about each data point in the time series. These
statistics can include the following: UniqueContributors -- the number of unique
contributors for each data point. MaxContributorValue -- the value of the top
contributor for each data point. The identity of the contributor might change for each data
point in the graph. If this rule aggregates by COUNT, the top contributor for each data
point is the contributor with the most occurrences in that period. If the rule aggregates
by SUM, the top contributor is the contributor with the highest sum in the log field
specified by the rule's Value, during that period. SampleCount -- the number of data
points matched by the rule. Sum -- the sum of the values from all contributors during
the time period represented by that data point. Minimum -- the minimum value from a
single observation during the time period represented by that data point. Maximum -- the
maximum value from a single observation during the time period represented by that data
point. Average -- the average value from all contributors during the time period
represented by that data point.
# Arguments
- `end_time`: The end time of the data to use in the report. When used in a raw HTTP Query
API, it is formatted as yyyy-MM-dd'T'HH:mm:ss. For example, 2019-07-01T23:59:59.
- `period`: The period, in seconds, to use for the statistics in the
InsightRuleMetricDatapoint results.
- `rule_name`: The name of the rule that you want to see data from.
- `start_time`: The start time of the data to use in the report. When used in a raw HTTP
Query API, it is formatted as yyyy-MM-dd'T'HH:mm:ss. For example, 2019-07-01T23:59:59.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxContributorCount"`: The maximum number of contributors to include in the report. The
range is 1 to 100. If you omit this, the default of 10 is used.
- `"Metrics"`: Specifies which metrics to use for aggregation of contributor values for the
report. You can specify one or more of the following metrics: UniqueContributors -- the
number of unique contributors for each data point. MaxContributorValue -- the value of
the top contributor for each data point. The identity of the contributor might change for
each data point in the graph. If this rule aggregates by COUNT, the top contributor for
each data point is the contributor with the most occurrences in that period. If the rule
aggregates by SUM, the top contributor is the contributor with the highest sum in the log
field specified by the rule's Value, during that period. SampleCount -- the number of
data points matched by the rule. Sum -- the sum of the values from all contributors
during the time period represented by that data point. Minimum -- the minimum value from
a single observation during the time period represented by that data point. Maximum --
the maximum value from a single observation during the time period represented by that data
point. Average -- the average value from all contributors during the time period
represented by that data point.
- `"OrderBy"`: Determines what statistic to use to rank the contributors. Valid values are
Sum and Maximum.
"""
function get_insight_rule_report(
EndTime, Period, RuleName, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"GetInsightRuleReport",
Dict{String,Any}(
"EndTime" => EndTime,
"Period" => Period,
"RuleName" => RuleName,
"StartTime" => StartTime,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_insight_rule_report(
EndTime,
Period,
RuleName,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetInsightRuleReport",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"Period" => Period,
"RuleName" => RuleName,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metric_data(end_time, metric_data_queries, start_time)
get_metric_data(end_time, metric_data_queries, start_time, params::Dict{String,<:Any})
You can use the GetMetricData API to retrieve CloudWatch metric values. The operation can
also include a CloudWatch Metrics Insights query, and one or more metric math functions. A
GetMetricData operation that does not include a query can retrieve as many as 500 different
metrics in a single request, with a total of as many as 100,800 data points. You can also
optionally perform metric math expressions on the values of the returned statistics, to
create new time series that represent new insights into your data. For example, using
Lambda metrics, you could divide the Errors metric by the Invocations metric to get an
error rate time series. For more information about metric math expressions, see Metric Math
Syntax and Functions in the Amazon CloudWatch User Guide. If you include a Metrics Insights
query, each GetMetricData operation can include only one query. But the same GetMetricData
operation can also retrieve other metrics. Metrics Insights queries can query only the most
recent three hours of metric data. For more information about Metrics Insights, see Query
your metrics with CloudWatch Metrics Insights. Calls to the GetMetricData API have a
different pricing structure than calls to GetMetricStatistics. For more information about
pricing, see Amazon CloudWatch Pricing. Amazon CloudWatch retains metric data as follows:
Data points with a period of less than 60 seconds are available for 3 hours. These data
points are high-resolution metrics and are available only for custom metrics that have been
defined with a StorageResolution of 1. Data points with a period of 60 seconds (1-minute)
are available for 15 days. Data points with a period of 300 seconds (5-minute) are
available for 63 days. Data points with a period of 3600 seconds (1 hour) are available
for 455 days (15 months). Data points that are initially published with a shorter period
are aggregated together for long-term storage. For example, if you collect data using a
period of 1 minute, the data remains available for 15 days with 1-minute resolution. After
15 days, this data is still available, but is aggregated and retrievable only with a
resolution of 5 minutes. After 63 days, the data is further aggregated and is available
with a resolution of 1 hour. If you omit Unit in your request, all data that was collected
with any unit is returned, along with the corresponding units that were specified when the
data was reported to CloudWatch. If you specify a unit, the operation returns only data
that was collected with that unit specified. If you specify a unit that does not match the
data collected, the results of the operation are null. CloudWatch does not perform unit
conversions. Using Metrics Insights queries with metric math You can't mix a Metric
Insights query and metric math syntax in the same expression, but you can reference results
from a Metrics Insights query within other Metric math expressions. A Metrics Insights
query without a GROUP BY clause returns a single time-series (TS), and can be used as input
for a metric math expression that expects a single time series. A Metrics Insights query
with a GROUP BY clause returns an array of time-series (TS[]), and can be used as input for
a metric math expression that expects an array of time series.
# Arguments
- `end_time`: The time stamp indicating the latest data to be returned. The value specified
is exclusive; results include data points up to the specified time stamp. For better
performance, specify StartTime and EndTime values that align with the value of the metric's
Period and sync up with the beginning and end of an hour. For example, if the Period of a
metric is 5 minutes, specifying 12:05 or 12:30 as EndTime can get a faster response from
CloudWatch than setting 12:07 or 12:29 as the EndTime.
- `metric_data_queries`: The metric queries to be returned. A single GetMetricData call can
include as many as 500 MetricDataQuery structures. Each of these structures can specify
either a metric to retrieve, a Metrics Insights query, or a math expression to perform on
retrieved data.
- `start_time`: The time stamp indicating the earliest data to be returned. The value
specified is inclusive; results include data points with the specified time stamp.
CloudWatch rounds the specified time stamp as follows: Start time less than 15 days ago -
Round down to the nearest whole minute. For example, 12:32:34 is rounded down to 12:32:00.
Start time between 15 and 63 days ago - Round down to the nearest 5-minute clock interval.
For example, 12:32:34 is rounded down to 12:30:00. Start time greater than 63 days ago -
Round down to the nearest 1-hour clock interval. For example, 12:32:34 is rounded down to
12:00:00. If you set Period to 5, 10, or 30, the start time of your request is rounded
down to the nearest time that corresponds to even 5-, 10-, or 30-second divisions of a
minute. For example, if you make a query at (HH:mm:ss) 01:05:23 for the previous 10-second
period, the start time of your request is rounded down and you receive data from 01:05:10
to 01:05:20. If you make a query at 15:07:17 for the previous 5 minutes of data, using a
period of 5 seconds, you receive data timestamped between 15:02:15 and 15:07:15. For
better performance, specify StartTime and EndTime values that align with the value of the
metric's Period and sync up with the beginning and end of an hour. For example, if the
Period of a metric is 5 minutes, specifying 12:05 or 12:30 as StartTime can get a faster
response from CloudWatch than setting 12:07 or 12:29 as the StartTime.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LabelOptions"`: This structure includes the Timezone parameter, which you can use to
specify your time zone so that the labels of returned data display the correct time for
your time zone.
- `"MaxDatapoints"`: The maximum number of data points the request should return before
paginating. If you omit this, the default of 100,800 is used.
- `"NextToken"`: Include this value, if it was returned by the previous GetMetricData
operation, to get the next set of data points.
- `"ScanBy"`: The order in which data points should be returned. TimestampDescending
returns the newest data first and paginates when the MaxDatapoints limit is reached.
TimestampAscending returns the oldest data first and paginates when the MaxDatapoints limit
is reached. If you omit this parameter, the default of TimestampDescending is used.
"""
function get_metric_data(
EndTime, MetricDataQueries, StartTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"GetMetricData",
Dict{String,Any}(
"EndTime" => EndTime,
"MetricDataQueries" => MetricDataQueries,
"StartTime" => StartTime,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metric_data(
EndTime,
MetricDataQueries,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetMetricData",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"MetricDataQueries" => MetricDataQueries,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metric_statistics(end_time, metric_name, namespace, period, start_time)
get_metric_statistics(end_time, metric_name, namespace, period, start_time, params::Dict{String,<:Any})
Gets statistics for the specified metric. The maximum number of data points returned from a
single call is 1,440. If you request more than 1,440 data points, CloudWatch returns an
error. To reduce the number of data points, you can narrow the specified time range and
make multiple requests across adjacent time ranges, or you can increase the specified
period. Data points are not returned in chronological order. CloudWatch aggregates data
points based on the length of the period that you specify. For example, if you request
statistics with a one-hour period, CloudWatch aggregates all data points with time stamps
that fall within each one-hour period. Therefore, the number of values aggregated by
CloudWatch is larger than the number of data points returned. CloudWatch needs raw data
points to calculate percentile statistics. If you publish data using a statistic set
instead, you can only retrieve percentile statistics for this data if one of the following
conditions is true: The SampleCount value of the statistic set is 1. The Min and the
Max values of the statistic set are equal. Percentile statistics are not available for
metrics when any of the metric values are negative numbers. Amazon CloudWatch retains
metric data as follows: Data points with a period of less than 60 seconds are available
for 3 hours. These data points are high-resolution metrics and are available only for
custom metrics that have been defined with a StorageResolution of 1. Data points with a
period of 60 seconds (1-minute) are available for 15 days. Data points with a period of
300 seconds (5-minute) are available for 63 days. Data points with a period of 3600
seconds (1 hour) are available for 455 days (15 months). Data points that are initially
published with a shorter period are aggregated together for long-term storage. For example,
if you collect data using a period of 1 minute, the data remains available for 15 days with
1-minute resolution. After 15 days, this data is still available, but is aggregated and
retrievable only with a resolution of 5 minutes. After 63 days, the data is further
aggregated and is available with a resolution of 1 hour. CloudWatch started retaining
5-minute and 1-hour metric data as of July 9, 2016. For information about metrics and
dimensions supported by Amazon Web Services services, see the Amazon CloudWatch Metrics and
Dimensions Reference in the Amazon CloudWatch User Guide.
# Arguments
- `end_time`: The time stamp that determines the last data point to return. The value
specified is exclusive; results include data points up to the specified time stamp. In a
raw HTTP query, the time stamp must be in ISO 8601 UTC format (for example,
2016-10-10T23:00:00Z).
- `metric_name`: The name of the metric, with or without spaces.
- `namespace`: The namespace of the metric, with or without spaces.
- `period`: The granularity, in seconds, of the returned data points. For metrics with
regular resolution, a period can be as short as one minute (60 seconds) and must be a
multiple of 60. For high-resolution metrics that are collected at intervals of less than
one minute, the period can be 1, 5, 10, 30, 60, or any multiple of 60. High-resolution
metrics are those metrics stored by a PutMetricData call that includes a StorageResolution
of 1 second. If the StartTime parameter specifies a time stamp that is greater than 3 hours
ago, you must specify the period as follows or no data points in that time range is
returned: Start time between 3 hours and 15 days ago - Use a multiple of 60 seconds (1
minute). Start time between 15 and 63 days ago - Use a multiple of 300 seconds (5
minutes). Start time greater than 63 days ago - Use a multiple of 3600 seconds (1 hour).
- `start_time`: The time stamp that determines the first data point to return. Start times
are evaluated relative to the time that CloudWatch receives the request. The value
specified is inclusive; results include data points with the specified time stamp. In a raw
HTTP query, the time stamp must be in ISO 8601 UTC format (for example,
2016-10-03T23:00:00Z). CloudWatch rounds the specified time stamp as follows: Start time
less than 15 days ago - Round down to the nearest whole minute. For example, 12:32:34 is
rounded down to 12:32:00. Start time between 15 and 63 days ago - Round down to the
nearest 5-minute clock interval. For example, 12:32:34 is rounded down to 12:30:00. Start
time greater than 63 days ago - Round down to the nearest 1-hour clock interval. For
example, 12:32:34 is rounded down to 12:00:00. If you set Period to 5, 10, or 30, the
start time of your request is rounded down to the nearest time that corresponds to even 5-,
10-, or 30-second divisions of a minute. For example, if you make a query at (HH:mm:ss)
01:05:23 for the previous 10-second period, the start time of your request is rounded down
and you receive data from 01:05:10 to 01:05:20. If you make a query at 15:07:17 for the
previous 5 minutes of data, using a period of 5 seconds, you receive data timestamped
between 15:02:15 and 15:07:15.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Dimensions"`: The dimensions. If the metric contains multiple dimensions, you must
include a value for each dimension. CloudWatch treats each unique combination of dimensions
as a separate metric. If a specific combination of dimensions was not published, you can't
retrieve statistics for it. You must specify the same dimensions that were used when the
metrics were created. For an example, see Dimension Combinations in the Amazon CloudWatch
User Guide. For more information about specifying dimensions, see Publishing Metrics in the
Amazon CloudWatch User Guide.
- `"ExtendedStatistics"`: The percentile statistics. Specify values between p0.0 and p100.
When calling GetMetricStatistics, you must specify either Statistics or ExtendedStatistics,
but not both. Percentile statistics are not available for metrics when any of the metric
values are negative numbers.
- `"Statistics"`: The metric statistics, other than percentile. For percentile statistics,
use ExtendedStatistics. When calling GetMetricStatistics, you must specify either
Statistics or ExtendedStatistics, but not both.
- `"Unit"`: The unit for a given metric. If you omit Unit, all data that was collected with
any unit is returned, along with the corresponding units that were specified when the data
was reported to CloudWatch. If you specify a unit, the operation returns only data that was
collected with that unit specified. If you specify a unit that does not match the data
collected, the results of the operation are null. CloudWatch does not perform unit
conversions.
"""
function get_metric_statistics(
EndTime,
MetricName,
Namespace,
Period,
StartTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetMetricStatistics",
Dict{String,Any}(
"EndTime" => EndTime,
"MetricName" => MetricName,
"Namespace" => Namespace,
"Period" => Period,
"StartTime" => StartTime,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metric_statistics(
EndTime,
MetricName,
Namespace,
Period,
StartTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetMetricStatistics",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"EndTime" => EndTime,
"MetricName" => MetricName,
"Namespace" => Namespace,
"Period" => Period,
"StartTime" => StartTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metric_stream(name)
get_metric_stream(name, params::Dict{String,<:Any})
Returns information about the metric stream that you specify.
# Arguments
- `name`: The name of the metric stream to retrieve information about.
"""
function get_metric_stream(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"GetMetricStream",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metric_stream(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"GetMetricStream",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metric_widget_image(metric_widget)
get_metric_widget_image(metric_widget, params::Dict{String,<:Any})
You can use the GetMetricWidgetImage API to retrieve a snapshot graph of one or more Amazon
CloudWatch metrics as a bitmap image. You can then embed this image into your services and
products, such as wiki pages, reports, and documents. You could also retrieve images
regularly, such as every minute, and create your own custom live dashboard. The graph you
retrieve can include all CloudWatch metric graph features, including metric math and
horizontal and vertical annotations. There is a limit of 20 transactions per second for
this API. Each GetMetricWidgetImage action has the following limits: As many as 100
metrics in the graph. Up to 100 KB uncompressed payload.
# Arguments
- `metric_widget`: A JSON string that defines the bitmap graph to be retrieved. The string
includes the metrics to include in the graph, statistics, annotations, title, axis limits,
and so on. You can include only one MetricWidget parameter in each GetMetricWidgetImage
call. For more information about the syntax of MetricWidget see GetMetricWidgetImage:
Metric Widget Structure and Syntax. If any metric on the graph could not load all the
requested data points, an orange triangle with an exclamation point appears next to the
graph legend.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"OutputFormat"`: The format of the resulting image. Only PNG images are supported. The
default is png. If you specify png, the API returns an HTTP response with the content-type
set to text/xml. The image data is in a MetricWidgetImage field. For example:
<GetMetricWidgetImageResponse xmlns=<URLstring>>
<GetMetricWidgetImageResult> <MetricWidgetImage>
iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQEAYAAAAip... </MetricWidgetImage>
</GetMetricWidgetImageResult> <ResponseMetadata>
<RequestId>6f0d4192-4d42-11e8-82c1-f539a07e0e3b</RequestId>
</ResponseMetadata> </GetMetricWidgetImageResponse> The image/png setting is
intended only for custom HTTP requests. For most use cases, and all actions using an Amazon
Web Services SDK, you should use png. If you specify image/png, the HTTP response has a
content-type set to image/png, and the body of the response is a PNG image.
"""
function get_metric_widget_image(
MetricWidget; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"GetMetricWidgetImage",
Dict{String,Any}("MetricWidget" => MetricWidget);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metric_widget_image(
MetricWidget,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"GetMetricWidgetImage",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("MetricWidget" => MetricWidget), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_dashboards()
list_dashboards(params::Dict{String,<:Any})
Returns a list of the dashboards for your account. If you include DashboardNamePrefix, only
those dashboards with names starting with the prefix are listed. Otherwise, all dashboards
in your account are listed. ListDashboards returns up to 1000 results on one page. If
there are more than 1000 dashboards, you can call ListDashboards again and include the
value you received for NextToken in the first call, to receive the next 1000 results.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DashboardNamePrefix"`: If you specify this parameter, only the dashboards with names
starting with the specified string are listed. The maximum length is 255, and valid
characters are A-Z, a-z, 0-9, \".\", \"-\", and \"_\".
- `"NextToken"`: The token returned by a previous call to indicate that there is more data
available.
"""
function list_dashboards(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"ListDashboards"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_dashboards(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"ListDashboards", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_managed_insight_rules(resource_arn)
list_managed_insight_rules(resource_arn, params::Dict{String,<:Any})
Returns a list that contains the number of managed Contributor Insights rules in your
account.
# Arguments
- `resource_arn`: The ARN of an Amazon Web Services resource that has managed Contributor
Insights rules.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation. If you omit
this parameter, the default number is used. The default number is 100.
- `"NextToken"`: Include this value to get the next set of rules if the value was returned
by the previous operation.
"""
function list_managed_insight_rules(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"ListManagedInsightRules",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_managed_insight_rules(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"ListManagedInsightRules",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_metric_streams()
list_metric_streams(params::Dict{String,<:Any})
Returns a list of metric streams in this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in one operation.
- `"NextToken"`: Include this value, if it was returned by the previous call, to get the
next set of metric streams.
"""
function list_metric_streams(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"ListMetricStreams"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_metric_streams(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"ListMetricStreams", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_metrics()
list_metrics(params::Dict{String,<:Any})
List the specified metrics. You can use the returned metrics with GetMetricData or
GetMetricStatistics to get statistical data. Up to 500 results are returned for any one
call. To retrieve additional results, use the returned token with subsequent calls. After
you create a metric, allow up to 15 minutes for the metric to appear. To see metric
statistics sooner, use GetMetricData or GetMetricStatistics. If you are using CloudWatch
cross-account observability, you can use this operation in a monitoring account and view
metrics from the linked source accounts. For more information, see CloudWatch cross-account
observability. ListMetrics doesn't return information about metrics if those metrics
haven't reported data in the past two weeks. To retrieve those metrics, use GetMetricData
or GetMetricStatistics.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Dimensions"`: The dimensions to filter against. Only the dimensions that match exactly
will be returned.
- `"IncludeLinkedAccounts"`: If you are using this operation in a monitoring account,
specify true to include metrics from source accounts in the returned data. The default is
false.
- `"MetricName"`: The name of the metric to filter against. Only the metrics with names
that match exactly will be returned.
- `"Namespace"`: The metric namespace to filter against. Only the namespace that matches
exactly will be returned.
- `"NextToken"`: The token returned by a previous call to indicate that there is more data
available.
- `"OwningAccount"`: When you use this operation in a monitoring account, use this field to
return metrics only from one source account. To do so, specify that source account ID in
this field, and also specify true for IncludeLinkedAccounts.
- `"RecentlyActive"`: To filter the results to show only metrics that have had data points
published in the past three hours, specify this parameter with a value of PT3H. This is the
only valid value for this parameter. The results that are returned are an approximation of
the value you specify. There is a low probability that the returned results include metrics
with last published data as much as 40 minutes more than the specified time interval.
"""
function list_metrics(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch("ListMetrics"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_metrics(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"ListMetrics", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Displays the tags associated with a CloudWatch resource. Currently, alarms and Contributor
Insights rules support tagging.
# Arguments
- `resource_arn`: The ARN of the CloudWatch resource that you want to view tags for. The
ARN format of an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name The ARN
format of a Contributor Insights rule is
arn:aws:cloudwatch:Region:account-id:insight-rule/insight-rule-name For more information
about ARN format, see Resource Types Defined by Amazon CloudWatch in the Amazon Web
Services General Reference.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_anomaly_detector()
put_anomaly_detector(params::Dict{String,<:Any})
Creates an anomaly detection model for a CloudWatch metric. You can use the model to
display a band of expected normal values when the metric is graphed. If you have enabled
unified cross-account observability, and this account is a monitoring account, the metric
can be in the same account or a source account. You can specify the account ID in the
object you specify in the SingleMetricAnomalyDetector parameter. For more information, see
CloudWatch Anomaly Detection.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Configuration"`: The configuration specifies details about how the anomaly detection
model is to be trained, including time ranges to exclude when training and updating the
model. You can specify as many as 10 time ranges. The configuration can also include the
time zone to use for the metric.
- `"Dimensions"`: The metric dimensions to create the anomaly detection model for.
- `"MetricCharacteristics"`: Use this object to include parameters to provide information
about your metric to CloudWatch to help it build more accurate anomaly detection models.
Currently, it includes the PeriodicSpikes parameter.
- `"MetricMathAnomalyDetector"`: The metric math anomaly detector to be created. When using
MetricMathAnomalyDetector, you cannot include the following parameters in the same
operation: Dimensions MetricName Namespace Stat the
SingleMetricAnomalyDetector parameters of PutAnomalyDetectorInput Instead, specify the
metric math anomaly detector attributes as part of the property MetricMathAnomalyDetector.
- `"MetricName"`: The name of the metric to create the anomaly detection model for.
- `"Namespace"`: The namespace of the metric to create the anomaly detection model for.
- `"SingleMetricAnomalyDetector"`: A single metric anomaly detector to be created. When
using SingleMetricAnomalyDetector, you cannot include the following parameters in the same
operation: Dimensions MetricName Namespace Stat the
MetricMathAnomalyDetector parameters of PutAnomalyDetectorInput Instead, specify the
single metric anomaly detector attributes as part of the property
SingleMetricAnomalyDetector.
- `"Stat"`: The statistic to use for the metric and the anomaly detection model.
"""
function put_anomaly_detector(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"PutAnomalyDetector"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function put_anomaly_detector(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutAnomalyDetector", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_composite_alarm(alarm_name, alarm_rule)
put_composite_alarm(alarm_name, alarm_rule, params::Dict{String,<:Any})
Creates or updates a composite alarm. When you create a composite alarm, you specify a rule
expression for the alarm that takes into account the alarm states of other alarms that you
have created. The composite alarm goes into ALARM state only if all conditions of the rule
are met. The alarms specified in a composite alarm's rule expression can include metric
alarms and other composite alarms. The rule expression of a composite alarm can include as
many as 100 underlying alarms. Any single alarm can be included in the rule expressions of
as many as 150 composite alarms. Using composite alarms can reduce alarm noise. You can
create multiple metric alarms, and also create a composite alarm and set up alerts only for
the composite alarm. For example, you could create a composite alarm that goes into ALARM
state only when more than one of the underlying metric alarms are in ALARM state. Composite
alarms can take the following actions: Notify Amazon SNS topics. Invoke Lambda
functions. Create OpsItems in Systems Manager Ops Center. Create incidents in Systems
Manager Incident Manager. It is possible to create a loop or cycle of composite alarms,
where composite alarm A depends on composite alarm B, and composite alarm B also depends on
composite alarm A. In this scenario, you can't delete any composite alarm that is part of
the cycle because there is always still a composite alarm that depends on that alarm that
you want to delete. To get out of such a situation, you must break the cycle by changing
the rule of one of the composite alarms in the cycle to remove a dependency that creates
the cycle. The simplest change to make to break a cycle is to change the AlarmRule of one
of the alarms to false. Additionally, the evaluation of composite alarms stops if
CloudWatch detects a cycle in the evaluation path. When this operation creates an alarm,
the alarm state is immediately set to INSUFFICIENT_DATA. The alarm is then evaluated and
its state is set appropriately. Any actions associated with the new state are then
executed. For a composite alarm, this initial time after creation is the only time that the
alarm can be in INSUFFICIENT_DATA state. When you update an existing alarm, its state is
left unchanged, but the update completely overwrites the previous configuration of the
alarm. To use this operation, you must be signed on with the cloudwatch:PutCompositeAlarm
permission that is scoped to *. You can't create a composite alarms if your
cloudwatch:PutCompositeAlarm permission has a narrower scope. If you are an IAM user, you
must have iam:CreateServiceLinkedRole to create a composite alarm that has Systems Manager
OpsItem actions.
# Arguments
- `alarm_name`: The name for the composite alarm. This name must be unique within the
Region.
- `alarm_rule`: An expression that specifies which other alarms are to be evaluated to
determine this composite alarm's state. For each alarm that you reference, you designate a
function that specifies whether that alarm needs to be in ALARM state, OK state, or
INSUFFICIENT_DATA state. You can use operators (AND, OR and NOT) to combine multiple
functions in a single expression. You can use parenthesis to logically group the functions
in your expression. You can use either alarm names or ARNs to reference the other alarms
that are to be evaluated. Functions can include the following: ALARM(\"alarm-name or
alarm-ARN\") is TRUE if the named alarm is in ALARM state. OK(\"alarm-name or
alarm-ARN\") is TRUE if the named alarm is in OK state. INSUFFICIENT_DATA(\"alarm-name
or alarm-ARN\") is TRUE if the named alarm is in INSUFFICIENT_DATA state. TRUE always
evaluates to TRUE. FALSE always evaluates to FALSE. TRUE and FALSE are useful for
testing a complex AlarmRule structure, and for testing your alarm actions. Alarm names
specified in AlarmRule can be surrounded with double-quotes (\"), but do not have to be.
The following are some examples of AlarmRule: ALARM(CPUUtilizationTooHigh) AND
ALARM(DiskReadOpsTooHigh) specifies that the composite alarm goes into ALARM state only if
both CPUUtilizationTooHigh and DiskReadOpsTooHigh alarms are in ALARM state.
ALARM(CPUUtilizationTooHigh) AND NOT ALARM(DeploymentInProgress) specifies that the alarm
goes to ALARM state if CPUUtilizationTooHigh is in ALARM state and DeploymentInProgress is
not in ALARM state. This example reduces alarm noise during a known deployment window.
(ALARM(CPUUtilizationTooHigh) OR ALARM(DiskReadOpsTooHigh)) AND OK(NetworkOutTooHigh) goes
into ALARM state if CPUUtilizationTooHigh OR DiskReadOpsTooHigh is in ALARM state, and if
NetworkOutTooHigh is in OK state. This provides another example of using a composite alarm
to prevent noise. This rule ensures that you are not notified with an alarm action on high
CPU or disk usage if a known network problem is also occurring. The AlarmRule can specify
as many as 100 \"children\" alarms. The AlarmRule expression can have as many as 500
elements. Elements are child alarms, TRUE or FALSE statements, and parentheses.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ActionsEnabled"`: Indicates whether actions should be executed during any changes to
the alarm state of the composite alarm. The default is TRUE.
- `"ActionsSuppressor"`: Actions will be suppressed if the suppressor alarm is in the
ALARM state. ActionsSuppressor can be an AlarmName or an Amazon Resource Name (ARN) from an
existing alarm.
- `"ActionsSuppressorExtensionPeriod"`: The maximum time in seconds that the composite
alarm waits after suppressor alarm goes out of the ALARM state. After this time, the
composite alarm performs its actions. ExtensionPeriod is required only when
ActionsSuppressor is specified.
- `"ActionsSuppressorWaitPeriod"`: The maximum time in seconds that the composite alarm
waits for the suppressor alarm to go into the ALARM state. After this time, the composite
alarm performs its actions. WaitPeriod is required only when ActionsSuppressor is
specified.
- `"AlarmActions"`: The actions to execute when this alarm transitions to the ALARM state
from any other state. Each action is specified as an Amazon Resource Name (ARN). Valid
Values: ] Amazon SNS actions: arn:aws:sns:region:account-id:sns-topic-name Lambda
actions: Invoke the latest version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name Invoke a specific version of a
Lambda function: arn:aws:lambda:region:account-id:function:function-name:version-number
Invoke a function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name Systems Manager
actions: arn:aws:ssm:region:account-id:opsitem:severity
- `"AlarmDescription"`: The description for the composite alarm.
- `"InsufficientDataActions"`: The actions to execute when this alarm transitions to the
INSUFFICIENT_DATA state from any other state. Each action is specified as an Amazon
Resource Name (ARN). Valid Values: ] Amazon SNS actions:
arn:aws:sns:region:account-id:sns-topic-name Lambda actions: Invoke the latest
version of a Lambda function: arn:aws:lambda:region:account-id:function:function-name
Invoke a specific version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name:version-number Invoke a
function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name
- `"OKActions"`: The actions to execute when this alarm transitions to an OK state from any
other state. Each action is specified as an Amazon Resource Name (ARN). Valid Values: ]
Amazon SNS actions: arn:aws:sns:region:account-id:sns-topic-name Lambda actions:
Invoke the latest version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name Invoke a specific version of a
Lambda function: arn:aws:lambda:region:account-id:function:function-name:version-number
Invoke a function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name
- `"Tags"`: A list of key-value pairs to associate with the alarm. You can associate as
many as 50 tags with an alarm. To be able to associate tags with the alarm when you create
the alarm, you must have the cloudwatch:TagResource permission. Tags can help you organize
and categorize your resources. You can also use them to scope user permissions by granting
a user permission to access or change only resources with certain tag values. If you are
using this operation to update an existing alarm, any tags you specify in this parameter
are ignored. To change the tags of an existing alarm, use TagResource or UntagResource.
"""
function put_composite_alarm(
AlarmName, AlarmRule; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutCompositeAlarm",
Dict{String,Any}("AlarmName" => AlarmName, "AlarmRule" => AlarmRule);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_composite_alarm(
AlarmName,
AlarmRule,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutCompositeAlarm",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("AlarmName" => AlarmName, "AlarmRule" => AlarmRule),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_dashboard(dashboard_body, dashboard_name)
put_dashboard(dashboard_body, dashboard_name, params::Dict{String,<:Any})
Creates a dashboard if it does not already exist, or updates an existing dashboard. If you
update a dashboard, the entire contents are replaced with what you specify here. All
dashboards in your account are global, not region-specific. A simple way to create a
dashboard using PutDashboard is to copy an existing dashboard. To copy an existing
dashboard using the console, you can load the dashboard and then use the View/edit source
command in the Actions menu to display the JSON block for that dashboard. Another way to
copy a dashboard is to use GetDashboard, and then use the data returned within
DashboardBody as the template for the new dashboard when you call PutDashboard. When you
create a dashboard with PutDashboard, a good practice is to add a text widget at the top of
the dashboard with a message that the dashboard was created by script and should not be
changed in the console. This message could also point console users to the location of the
DashboardBody script or the CloudFormation template used to create the dashboard.
# Arguments
- `dashboard_body`: The detailed information about the dashboard in JSON format, including
the widgets to include and their location on the dashboard. This parameter is required. For
more information about the syntax, see Dashboard Body Structure and Syntax.
- `dashboard_name`: The name of the dashboard. If a dashboard with this name already
exists, this call modifies that dashboard, replacing its current contents. Otherwise, a new
dashboard is created. The maximum length is 255, and valid characters are A-Z, a-z, 0-9,
\"-\", and \"_\". This parameter is required.
"""
function put_dashboard(
DashboardBody, DashboardName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutDashboard",
Dict{String,Any}(
"DashboardBody" => DashboardBody, "DashboardName" => DashboardName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_dashboard(
DashboardBody,
DashboardName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutDashboard",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"DashboardBody" => DashboardBody, "DashboardName" => DashboardName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_insight_rule(rule_definition, rule_name)
put_insight_rule(rule_definition, rule_name, params::Dict{String,<:Any})
Creates a Contributor Insights rule. Rules evaluate log events in a CloudWatch Logs log
group, enabling you to find contributor data for the log events in that log group. For more
information, see Using Contributor Insights to Analyze High-Cardinality Data. If you create
a rule, delete it, and then re-create it with the same name, historical data from the first
time the rule was created might not be available.
# Arguments
- `rule_definition`: The definition of the rule, as a JSON object. For details on the valid
syntax, see Contributor Insights Rule Syntax.
- `rule_name`: A unique name for the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"RuleState"`: The state of the rule. Valid values are ENABLED and DISABLED.
- `"Tags"`: A list of key-value pairs to associate with the Contributor Insights rule. You
can associate as many as 50 tags with a rule. Tags can help you organize and categorize
your resources. You can also use them to scope user permissions, by granting a user
permission to access or change only the resources that have certain tag values. To be able
to associate tags with a rule, you must have the cloudwatch:TagResource permission in
addition to the cloudwatch:PutInsightRule permission. If you are using this operation to
update an existing Contributor Insights rule, any tags you specify in this parameter are
ignored. To change the tags of an existing rule, use TagResource.
"""
function put_insight_rule(
RuleDefinition, RuleName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutInsightRule",
Dict{String,Any}("RuleDefinition" => RuleDefinition, "RuleName" => RuleName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_insight_rule(
RuleDefinition,
RuleName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutInsightRule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"RuleDefinition" => RuleDefinition, "RuleName" => RuleName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_managed_insight_rules(managed_rules)
put_managed_insight_rules(managed_rules, params::Dict{String,<:Any})
Creates a managed Contributor Insights rule for a specified Amazon Web Services resource.
When you enable a managed rule, you create a Contributor Insights rule that collects data
from Amazon Web Services services. You cannot edit these rules with PutInsightRule. The
rules can be enabled, disabled, and deleted using EnableInsightRules, DisableInsightRules,
and DeleteInsightRules. If a previously created managed rule is currently disabled, a
subsequent call to this API will re-enable it. Use ListManagedInsightRules to describe all
available rules.
# Arguments
- `managed_rules`: A list of ManagedRules to enable.
"""
function put_managed_insight_rules(
ManagedRules; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutManagedInsightRules",
Dict{String,Any}("ManagedRules" => ManagedRules);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_managed_insight_rules(
ManagedRules,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutManagedInsightRules",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ManagedRules" => ManagedRules), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_metric_alarm(alarm_name, comparison_operator, evaluation_periods)
put_metric_alarm(alarm_name, comparison_operator, evaluation_periods, params::Dict{String,<:Any})
Creates or updates an alarm and associates it with the specified metric, metric math
expression, anomaly detection model, or Metrics Insights query. For more information about
using a Metrics Insights query for an alarm, see Create alarms on Metrics Insights queries.
Alarms based on anomaly detection models cannot have Auto Scaling actions. When this
operation creates an alarm, the alarm state is immediately set to INSUFFICIENT_DATA. The
alarm is then evaluated and its state is set appropriately. Any actions associated with the
new state are then executed. When you update an existing alarm, its state is left
unchanged, but the update completely overwrites the previous configuration of the alarm. If
you are an IAM user, you must have Amazon EC2 permissions for some alarm operations: The
iam:CreateServiceLinkedRole permission for all alarms with EC2 actions The
iam:CreateServiceLinkedRole permissions to create an alarm with Systems Manager OpsItem or
response plan actions. The first time you create an alarm in the Amazon Web Services
Management Console, the CLI, or by using the PutMetricAlarm API, CloudWatch creates the
necessary service-linked role for you. The service-linked roles are called
AWSServiceRoleForCloudWatchEvents and AWSServiceRoleForCloudWatchAlarms_ActionSSM. For more
information, see Amazon Web Services service-linked role. Each PutMetricAlarm action has a
maximum uncompressed payload of 120 KB. Cross-account alarms You can set an alarm on
metrics in the current account, or in another account. To create a cross-account alarm that
watches a metric in a different account, you must have completed the following
pre-requisites: The account where the metrics are located (the sharing account) must
already have a sharing role named CloudWatch-CrossAccountSharingRole. If it does not
already have this role, you must create it using the instructions in Set up a sharing
account in Cross-account cross-Region CloudWatch console. The policy for that role must
grant access to the ID of the account where you are creating the alarm. The account
where you are creating the alarm (the monitoring account) must already have a
service-linked role named AWSServiceRoleForCloudWatchCrossAccount to allow CloudWatch to
assume the sharing role in the sharing account. If it does not, you must create it
following the directions in Set up a monitoring account in Cross-account cross-Region
CloudWatch console.
# Arguments
- `alarm_name`: The name for the alarm. This name must be unique within the Region. The
name must contain only UTF-8 characters, and can't contain ASCII control characters
- `comparison_operator`: The arithmetic operation to use when comparing the specified
statistic and threshold. The specified statistic value is used as the first operand. The
values LessThanLowerOrGreaterThanUpperThreshold, LessThanLowerThreshold, and
GreaterThanUpperThreshold are used only for alarms based on anomaly detection models.
- `evaluation_periods`: The number of periods over which data is compared to the specified
threshold. If you are setting an alarm that requires that a number of consecutive data
points be breaching to trigger the alarm, this value specifies that number. If you are
setting an \"M out of N\" alarm, this value is the N. An alarm's total current evaluation
period can be no longer than one day, so this number multiplied by Period cannot be more
than 86,400 seconds.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ActionsEnabled"`: Indicates whether actions should be executed during any changes to
the alarm state. The default is TRUE.
- `"AlarmActions"`: The actions to execute when this alarm transitions to the ALARM state
from any other state. Each action is specified as an Amazon Resource Name (ARN). Valid
values: EC2 actions: arn:aws:automate:region:ec2:stop
arn:aws:automate:region:ec2:terminate arn:aws:automate:region:ec2:reboot
arn:aws:automate:region:ec2:recover
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Stop/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Terminate/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Reboot/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Recover/1.0 Autoscaling
action:
arn:aws:autoscaling:region:account-id:scalingPolicy:policy-id:autoScalingGroupName/group-fri
endly-name:policyName/policy-friendly-name Lambda actions: Invoke the latest
version of a Lambda function: arn:aws:lambda:region:account-id:function:function-name
Invoke a specific version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name:version-number Invoke a
function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name SNS notification
action: arn:aws:sns:region:account-id:sns-topic-name SSM integration actions:
arn:aws:ssm:region:account-id:opsitem:severity#CATEGORY=category-name
arn:aws:ssm-incidents::account-id:responseplan/response-plan-name
- `"AlarmDescription"`: The description for the alarm.
- `"DatapointsToAlarm"`: The number of data points that must be breaching to trigger the
alarm. This is used only if you are setting an \"M out of N\" alarm. In that case, this
value is the M. For more information, see Evaluating an Alarm in the Amazon CloudWatch User
Guide.
- `"Dimensions"`: The dimensions for the metric specified in MetricName.
- `"EvaluateLowSampleCountPercentile"`: Used only for alarms based on percentiles. If you
specify ignore, the alarm state does not change during periods with too few data points to
be statistically significant. If you specify evaluate or omit this parameter, the alarm is
always evaluated and possibly changes state no matter how many data points are available.
For more information, see Percentile-Based CloudWatch Alarms and Low Data Samples. Valid
Values: evaluate | ignore
- `"ExtendedStatistic"`: The extended statistic for the metric specified in MetricName.
When you call PutMetricAlarm and specify a MetricName, you must specify either Statistic or
ExtendedStatistic but not both. If you specify ExtendedStatistic, the following are valid
values: p90 tm90 tc90 ts90 wm90 IQM PR(n:m) where n and m are
values of the metric TC(X%:X%) where X is between 10 and 90 inclusive. TM(X%:X%)
where X is between 10 and 90 inclusive. TS(X%:X%) where X is between 10 and 90
inclusive. WM(X%:X%) where X is between 10 and 90 inclusive. For more information
about these extended statistics, see CloudWatch statistics definitions.
- `"InsufficientDataActions"`: The actions to execute when this alarm transitions to the
INSUFFICIENT_DATA state from any other state. Each action is specified as an Amazon
Resource Name (ARN). Valid values: EC2 actions: arn:aws:automate:region:ec2:stop
arn:aws:automate:region:ec2:terminate arn:aws:automate:region:ec2:reboot
arn:aws:automate:region:ec2:recover
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Stop/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Terminate/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Reboot/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Recover/1.0 Autoscaling
action:
arn:aws:autoscaling:region:account-id:scalingPolicy:policy-id:autoScalingGroupName/group-fri
endly-name:policyName/policy-friendly-name Lambda actions: Invoke the latest
version of a Lambda function: arn:aws:lambda:region:account-id:function:function-name
Invoke a specific version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name:version-number Invoke a
function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name SNS notification
action: arn:aws:sns:region:account-id:sns-topic-name SSM integration actions:
arn:aws:ssm:region:account-id:opsitem:severity#CATEGORY=category-name
arn:aws:ssm-incidents::account-id:responseplan/response-plan-name
- `"MetricName"`: The name for the metric associated with the alarm. For each
PutMetricAlarm operation, you must specify either MetricName or a Metrics array. If you are
creating an alarm based on a math expression, you cannot specify this parameter, or any of
the Namespace, Dimensions, Period, Unit, Statistic, or ExtendedStatistic parameters.
Instead, you specify all this information in the Metrics array.
- `"Metrics"`: An array of MetricDataQuery structures that enable you to create an alarm
based on the result of a metric math expression. For each PutMetricAlarm operation, you
must specify either MetricName or a Metrics array. Each item in the Metrics array either
retrieves a metric or performs a math expression. One item in the Metrics array is the
expression that the alarm watches. You designate this expression by setting ReturnData to
true for this object in the array. For more information, see MetricDataQuery. If you use
the Metrics parameter, you cannot include the Namespace, MetricName, Dimensions, Period,
Unit, Statistic, or ExtendedStatistic parameters of PutMetricAlarm in the same operation.
Instead, you retrieve the metrics you are using in your math expression as part of the
Metrics array.
- `"Namespace"`: The namespace for the metric associated specified in MetricName.
- `"OKActions"`: The actions to execute when this alarm transitions to an OK state from any
other state. Each action is specified as an Amazon Resource Name (ARN). Valid values: EC2
actions: arn:aws:automate:region:ec2:stop arn:aws:automate:region:ec2:terminate
arn:aws:automate:region:ec2:reboot arn:aws:automate:region:ec2:recover
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Stop/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Terminate/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Reboot/1.0
arn:aws:swf:region:account-id:action/actions/AWS_EC2.InstanceId.Recover/1.0 Autoscaling
action:
arn:aws:autoscaling:region:account-id:scalingPolicy:policy-id:autoScalingGroupName/group-fri
endly-name:policyName/policy-friendly-name Lambda actions: Invoke the latest
version of a Lambda function: arn:aws:lambda:region:account-id:function:function-name
Invoke a specific version of a Lambda function:
arn:aws:lambda:region:account-id:function:function-name:version-number Invoke a
function by using an alias Lambda function:
arn:aws:lambda:region:account-id:function:function-name:alias-name SNS notification
action: arn:aws:sns:region:account-id:sns-topic-name SSM integration actions:
arn:aws:ssm:region:account-id:opsitem:severity#CATEGORY=category-name
arn:aws:ssm-incidents::account-id:responseplan/response-plan-name
- `"Period"`: The length, in seconds, used each time the metric specified in MetricName is
evaluated. Valid values are 10, 30, and any multiple of 60. Period is required for alarms
based on static thresholds. If you are creating an alarm based on a metric math expression,
you specify the period for each metric within the objects in the Metrics array. Be sure to
specify 10 or 30 only for metrics that are stored by a PutMetricData call with a
StorageResolution of 1. If you specify a period of 10 or 30 for a metric that does not have
sub-minute resolution, the alarm still attempts to gather data at the period rate that you
specify. In this case, it does not receive data for the attempts that do not correspond to
a one-minute data resolution, and the alarm might often lapse into INSUFFICENT_DATA status.
Specifying 10 or 30 also sets this alarm as a high-resolution alarm, which has a higher
charge than other alarms. For more information about pricing, see Amazon CloudWatch
Pricing. An alarm's total current evaluation period can be no longer than one day, so
Period multiplied by EvaluationPeriods cannot be more than 86,400 seconds.
- `"Statistic"`: The statistic for the metric specified in MetricName, other than
percentile. For percentile statistics, use ExtendedStatistic. When you call PutMetricAlarm
and specify a MetricName, you must specify either Statistic or ExtendedStatistic, but not
both.
- `"Tags"`: A list of key-value pairs to associate with the alarm. You can associate as
many as 50 tags with an alarm. To be able to associate tags with the alarm when you create
the alarm, you must have the cloudwatch:TagResource permission. Tags can help you organize
and categorize your resources. You can also use them to scope user permissions by granting
a user permission to access or change only resources with certain tag values. If you are
using this operation to update an existing alarm, any tags you specify in this parameter
are ignored. To change the tags of an existing alarm, use TagResource or UntagResource.
- `"Threshold"`: The value against which the specified statistic is compared. This
parameter is required for alarms based on static thresholds, but should not be used for
alarms based on anomaly detection models.
- `"ThresholdMetricId"`: If this is an alarm based on an anomaly detection model, make this
value match the ID of the ANOMALY_DETECTION_BAND function. For an example of how to use
this parameter, see the Anomaly Detection Model Alarm example on this page. If your alarm
uses this parameter, it cannot have Auto Scaling actions.
- `"TreatMissingData"`: Sets how this alarm is to handle missing data points. If
TreatMissingData is omitted, the default behavior of missing is used. For more information,
see Configuring How CloudWatch Alarms Treats Missing Data. Valid Values: breaching |
notBreaching | ignore | missing Alarms that evaluate metrics in the AWS/DynamoDB
namespace always ignore missing data even if you choose a different option for
TreatMissingData. When an AWS/DynamoDB metric has missing data, alarms that evaluate that
metric remain in their current state.
- `"Unit"`: The unit of measure for the statistic. For example, the units for the Amazon
EC2 NetworkIn metric are Bytes because NetworkIn tracks the number of bytes that an
instance receives on all network interfaces. You can also specify a unit when you create a
custom metric. Units help provide conceptual meaning to your data. Metric data points that
specify a unit of measure, such as Percent, are aggregated separately. If you are creating
an alarm based on a metric math expression, you can specify the unit for each metric (if
needed) within the objects in the Metrics array. If you don't specify Unit, CloudWatch
retrieves all unit types that have been published for the metric and attempts to evaluate
the alarm. Usually, metrics are published with only one unit, so the alarm works as
intended. However, if the metric is published with multiple types of units and you don't
specify a unit, the alarm's behavior is not defined and it behaves unpredictably. We
recommend omitting Unit so that you don't inadvertently specify an incorrect unit that is
not published for this metric. Doing so causes the alarm to be stuck in the INSUFFICIENT
DATA state.
"""
function put_metric_alarm(
AlarmName,
ComparisonOperator,
EvaluationPeriods;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutMetricAlarm",
Dict{String,Any}(
"AlarmName" => AlarmName,
"ComparisonOperator" => ComparisonOperator,
"EvaluationPeriods" => EvaluationPeriods,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_metric_alarm(
AlarmName,
ComparisonOperator,
EvaluationPeriods,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutMetricAlarm",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AlarmName" => AlarmName,
"ComparisonOperator" => ComparisonOperator,
"EvaluationPeriods" => EvaluationPeriods,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_metric_data(metric_data, namespace)
put_metric_data(metric_data, namespace, params::Dict{String,<:Any})
Publishes metric data points to Amazon CloudWatch. CloudWatch associates the data points
with the specified metric. If the specified metric does not exist, CloudWatch creates the
metric. When CloudWatch creates a metric, it can take up to fifteen minutes for the metric
to appear in calls to ListMetrics. You can publish either individual data points in the
Value field, or arrays of values and the number of times each value occurred during the
period by using the Values and Counts fields in the MetricData structure. Using the Values
and Counts method enables you to publish up to 150 values per metric with one PutMetricData
request, and supports retrieving percentile statistics on this data. Each PutMetricData
request is limited to 1 MB in size for HTTP POST requests. You can send a payload
compressed by gzip. Each request is also limited to no more than 1000 different metrics.
Although the Value parameter accepts numbers of type Double, CloudWatch rejects values that
are either too small or too large. Values must be in the range of -2^360 to 2^360. In
addition, special values (for example, NaN, +Infinity, -Infinity) are not supported. You
can use up to 30 dimensions per metric to further clarify what data the metric collects.
Each dimension consists of a Name and Value pair. For more information about specifying
dimensions, see Publishing Metrics in the Amazon CloudWatch User Guide. You specify the
time stamp to be associated with each data point. You can specify time stamps that are as
much as two weeks before the current date, and as much as 2 hours after the current day and
time. Data points with time stamps from 24 hours ago or longer can take at least 48 hours
to become available for GetMetricData or GetMetricStatistics from the time they are
submitted. Data points with time stamps between 3 and 24 hours ago can take as much as 2
hours to become available for for GetMetricData or GetMetricStatistics. CloudWatch needs
raw data points to calculate percentile statistics. If you publish data using a statistic
set instead, you can only retrieve percentile statistics for this data if one of the
following conditions is true: The SampleCount value of the statistic set is 1 and Min,
Max, and Sum are all equal. The Min and Max are equal, and Sum is equal to Min multiplied
by SampleCount.
# Arguments
- `metric_data`: The data for the metric. The array can include no more than 1000 metrics
per call.
- `namespace`: The namespace for the metric data. You can use ASCII characters for the
namespace, except for control characters which are not supported. To avoid conflicts with
Amazon Web Services service namespaces, you should not specify a namespace that begins with
AWS/
"""
function put_metric_data(
MetricData, Namespace; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"PutMetricData",
Dict{String,Any}("MetricData" => MetricData, "Namespace" => Namespace);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_metric_data(
MetricData,
Namespace,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutMetricData",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("MetricData" => MetricData, "Namespace" => Namespace),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_metric_stream(firehose_arn, name, output_format, role_arn)
put_metric_stream(firehose_arn, name, output_format, role_arn, params::Dict{String,<:Any})
Creates or updates a metric stream. Metric streams can automatically stream CloudWatch
metrics to Amazon Web Services destinations, including Amazon S3, and to many third-party
solutions. For more information, see Using Metric Streams. To create a metric stream, you
must be signed in to an account that has the iam:PassRole permission and either the
CloudWatchFullAccess policy or the cloudwatch:PutMetricStream permission. When you create
or update a metric stream, you choose one of the following: Stream metrics from all
metric namespaces in the account. Stream metrics from all metric namespaces in the
account, except for the namespaces that you list in ExcludeFilters. Stream metrics from
only the metric namespaces that you list in IncludeFilters. By default, a metric stream
always sends the MAX, MIN, SUM, and SAMPLECOUNT statistics for each metric that is
streamed. You can use the StatisticsConfigurations parameter to have the metric stream send
additional statistics in the stream. Streaming additional statistics incurs additional
costs. For more information, see Amazon CloudWatch Pricing. When you use PutMetricStream
to create a new metric stream, the stream is created in the running state. If you use it to
update an existing stream, the state of the stream is not changed. If you are using
CloudWatch cross-account observability and you create a metric stream in a monitoring
account, you can choose whether to include metrics from source accounts in the stream. For
more information, see CloudWatch cross-account observability.
# Arguments
- `firehose_arn`: The ARN of the Amazon Kinesis Data Firehose delivery stream to use for
this metric stream. This Amazon Kinesis Data Firehose delivery stream must already exist
and must be in the same account as the metric stream.
- `name`: If you are creating a new metric stream, this is the name for the new stream. The
name must be different than the names of other metric streams in this account and Region.
If you are updating a metric stream, specify the name of that stream here. Valid characters
are A-Z, a-z, 0-9, \"-\" and \"_\".
- `output_format`: The output format for the stream. Valid values are json,
opentelemetry1.0, and opentelemetry0.7. For more information about metric stream output
formats, see Metric streams output formats.
- `role_arn`: The ARN of an IAM role that this metric stream will use to access Amazon
Kinesis Data Firehose resources. This IAM role must already exist and must be in the same
account as the metric stream. This IAM role must include the following permissions:
firehose:PutRecord firehose:PutRecordBatch
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExcludeFilters"`: If you specify this parameter, the stream sends metrics from all
metric namespaces except for the namespaces that you specify here. You cannot include
ExcludeFilters and IncludeFilters in the same operation.
- `"IncludeFilters"`: If you specify this parameter, the stream sends only the metrics from
the metric namespaces that you specify here. You cannot include IncludeFilters and
ExcludeFilters in the same operation.
- `"IncludeLinkedAccountsMetrics"`: If you are creating a metric stream in a monitoring
account, specify true to include metrics from source accounts in the metric stream.
- `"StatisticsConfigurations"`: By default, a metric stream always sends the MAX, MIN, SUM,
and SAMPLECOUNT statistics for each metric that is streamed. You can use this parameter to
have the metric stream also send additional statistics in the stream. This array can have
up to 100 members. For each entry in this array, you specify one or more metrics and the
list of additional statistics to stream for those metrics. The additional statistics that
you can stream depend on the stream's OutputFormat. If the OutputFormat is json, you can
stream any additional statistic that is supported by CloudWatch, listed in CloudWatch
statistics definitions. If the OutputFormat is opentelemetry1.0 or opentelemetry0.7, you
can stream percentile statistics such as p95, p99.9, and so on.
- `"Tags"`: A list of key-value pairs to associate with the metric stream. You can
associate as many as 50 tags with a metric stream. Tags can help you organize and
categorize your resources. You can also use them to scope user permissions by granting a
user permission to access or change only resources with certain tag values. You can use
this parameter only when you are creating a new metric stream. If you are using this
operation to update an existing metric stream, any tags you specify in this parameter are
ignored. To change the tags of an existing metric stream, use TagResource or UntagResource.
"""
function put_metric_stream(
FirehoseArn,
Name,
OutputFormat,
RoleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutMetricStream",
Dict{String,Any}(
"FirehoseArn" => FirehoseArn,
"Name" => Name,
"OutputFormat" => OutputFormat,
"RoleArn" => RoleArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_metric_stream(
FirehoseArn,
Name,
OutputFormat,
RoleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"PutMetricStream",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"FirehoseArn" => FirehoseArn,
"Name" => Name,
"OutputFormat" => OutputFormat,
"RoleArn" => RoleArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
set_alarm_state(alarm_name, state_reason, state_value)
set_alarm_state(alarm_name, state_reason, state_value, params::Dict{String,<:Any})
Temporarily sets the state of an alarm for testing purposes. When the updated state differs
from the previous value, the action configured for the appropriate state is invoked. For
example, if your alarm is configured to send an Amazon SNS message when an alarm is
triggered, temporarily changing the alarm state to ALARM sends an SNS message. Metric
alarms returns to their actual state quickly, often within seconds. Because the metric
alarm state change happens quickly, it is typically only visible in the alarm's History tab
in the Amazon CloudWatch console or through DescribeAlarmHistory. If you use SetAlarmState
on a composite alarm, the composite alarm is not guaranteed to return to its actual state.
It returns to its actual state only once any of its children alarms change state. It is
also reevaluated if you update its configuration. If an alarm triggers EC2 Auto Scaling
policies or application Auto Scaling policies, you must include information in the
StateReasonData parameter to enable the policy to take the correct action.
# Arguments
- `alarm_name`: The name of the alarm.
- `state_reason`: The reason that this alarm is set to this specific state, in text format.
- `state_value`: The value of the state.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"StateReasonData"`: The reason that this alarm is set to this specific state, in JSON
format. For SNS or EC2 alarm actions, this is just informational. But for EC2 Auto Scaling
or application Auto Scaling alarm actions, the Auto Scaling policy uses the information in
this field to take the correct action.
"""
function set_alarm_state(
AlarmName, StateReason, StateValue; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"SetAlarmState",
Dict{String,Any}(
"AlarmName" => AlarmName,
"StateReason" => StateReason,
"StateValue" => StateValue,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function set_alarm_state(
AlarmName,
StateReason,
StateValue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"SetAlarmState",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AlarmName" => AlarmName,
"StateReason" => StateReason,
"StateValue" => StateValue,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_metric_streams(names)
start_metric_streams(names, params::Dict{String,<:Any})
Starts the streaming of metrics for one or more of your metric streams.
# Arguments
- `names`: The array of the names of metric streams to start streaming. This is an \"all or
nothing\" operation. If you do not have permission to access all of the metric streams that
you list here, then none of the streams that you list in the operation will start streaming.
"""
function start_metric_streams(Names; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"StartMetricStreams",
Dict{String,Any}("Names" => Names);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_metric_streams(
Names, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"StartMetricStreams",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Names" => Names), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_metric_streams(names)
stop_metric_streams(names, params::Dict{String,<:Any})
Stops the streaming of metrics for one or more of your metric streams.
# Arguments
- `names`: The array of the names of metric streams to stop streaming. This is an \"all or
nothing\" operation. If you do not have permission to access all of the metric streams that
you list here, then none of the streams that you list in the operation will stop streaming.
"""
function stop_metric_streams(Names; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"StopMetricStreams",
Dict{String,Any}("Names" => Names);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_metric_streams(
Names, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"StopMetricStreams",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Names" => Names), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns one or more tags (key-value pairs) to the specified CloudWatch resource. Currently,
the only CloudWatch resources that can be tagged are alarms and Contributor Insights rules.
Tags can help you organize and categorize your resources. You can also use them to scope
user permissions by granting a user permission to access or change only resources with
certain tag values. Tags don't have any semantic meaning to Amazon Web Services and are
interpreted strictly as strings of characters. You can use the TagResource action with an
alarm that already has tags. If you specify a new tag key for the alarm, this tag is
appended to the list of tags associated with the alarm. If you specify a tag key that is
already associated with the alarm, the new tag value that you specify replaces the previous
value for that tag. You can associate as many as 50 tags with a CloudWatch resource.
# Arguments
- `resource_arn`: The ARN of the CloudWatch resource that you're adding tags to. The ARN
format of an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name The ARN
format of a Contributor Insights rule is
arn:aws:cloudwatch:Region:account-id:insight-rule/insight-rule-name For more information
about ARN format, see Resource Types Defined by Amazon CloudWatch in the Amazon Web
Services General Reference.
- `tags`: The list of key-value pairs to associate with the alarm.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes one or more tags from the specified resource.
# Arguments
- `resource_arn`: The ARN of the CloudWatch resource that you're removing tags from. The
ARN format of an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name The ARN
format of a Contributor Insights rule is
arn:aws:cloudwatch:Region:account-id:insight-rule/insight-rule-name For more information
about ARN format, see Resource Types Defined by Amazon CloudWatch in the Amazon Web
Services General Reference.
- `tag_keys`: The list of tag keys to remove from the resource.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 78544 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudwatch_events
using AWS.Compat
using AWS.UUIDs
"""
activate_event_source(name)
activate_event_source(name, params::Dict{String,<:Any})
Activates a partner event source that has been deactivated. Once activated, your matching
event bus will start receiving events from the event source.
# Arguments
- `name`: The name of the partner event source to activate.
"""
function activate_event_source(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ActivateEventSource",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function activate_event_source(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ActivateEventSource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_replay(replay_name)
cancel_replay(replay_name, params::Dict{String,<:Any})
Cancels the specified replay.
# Arguments
- `replay_name`: The name of the replay to cancel.
"""
function cancel_replay(ReplayName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"CancelReplay",
Dict{String,Any}("ReplayName" => ReplayName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_replay(
ReplayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CancelReplay",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ReplayName" => ReplayName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_api_destination(connection_arn, http_method, invocation_endpoint, name)
create_api_destination(connection_arn, http_method, invocation_endpoint, name, params::Dict{String,<:Any})
Creates an API destination, which is an HTTP invocation endpoint configured as a target for
events.
# Arguments
- `connection_arn`: The ARN of the connection to use for the API destination. The
destination endpoint must support the authorization type specified for the connection.
- `http_method`: The method to use for the request to the HTTP invocation endpoint.
- `invocation_endpoint`: The URL to the HTTP invocation endpoint for the API destination.
- `name`: The name for the API destination to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description for the API destination to create.
- `"InvocationRateLimitPerSecond"`: The maximum number of requests per second to send to
the HTTP invocation endpoint.
"""
function create_api_destination(
ConnectionArn,
HttpMethod,
InvocationEndpoint,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreateApiDestination",
Dict{String,Any}(
"ConnectionArn" => ConnectionArn,
"HttpMethod" => HttpMethod,
"InvocationEndpoint" => InvocationEndpoint,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_api_destination(
ConnectionArn,
HttpMethod,
InvocationEndpoint,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreateApiDestination",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConnectionArn" => ConnectionArn,
"HttpMethod" => HttpMethod,
"InvocationEndpoint" => InvocationEndpoint,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_archive(archive_name, event_source_arn)
create_archive(archive_name, event_source_arn, params::Dict{String,<:Any})
Creates an archive of events with the specified settings. When you create an archive,
incoming events might not immediately start being sent to the archive. Allow a short period
of time for changes to take effect. If you do not specify a pattern to filter events sent
to the archive, all events are sent to the archive except replayed events. Replayed events
are not sent to an archive.
# Arguments
- `archive_name`: The name for the archive to create.
- `event_source_arn`: The ARN of the event bus that sends events to the archive.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description for the archive.
- `"EventPattern"`: An event pattern to use to filter events sent to the archive.
- `"RetentionDays"`: The number of days to retain events for. Default value is 0. If set to
0, events are retained indefinitely
"""
function create_archive(
ArchiveName, EventSourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"CreateArchive",
Dict{String,Any}("ArchiveName" => ArchiveName, "EventSourceArn" => EventSourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_archive(
ArchiveName,
EventSourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreateArchive",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ArchiveName" => ArchiveName, "EventSourceArn" => EventSourceArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_connection(auth_parameters, authorization_type, name)
create_connection(auth_parameters, authorization_type, name, params::Dict{String,<:Any})
Creates a connection. A connection defines the authorization type and credentials to use
for authorization with an API destination HTTP endpoint.
# Arguments
- `auth_parameters`: A CreateConnectionAuthRequestParameters object that contains the
authorization parameters to use to authorize with the endpoint.
- `authorization_type`: The type of authorization to use for the connection.
- `name`: The name for the connection to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description for the connection to create.
"""
function create_connection(
AuthParameters,
AuthorizationType,
Name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreateConnection",
Dict{String,Any}(
"AuthParameters" => AuthParameters,
"AuthorizationType" => AuthorizationType,
"Name" => Name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_connection(
AuthParameters,
AuthorizationType,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreateConnection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"AuthParameters" => AuthParameters,
"AuthorizationType" => AuthorizationType,
"Name" => Name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_event_bus(name)
create_event_bus(name, params::Dict{String,<:Any})
Creates a new event bus within your account. This can be a custom event bus which you can
use to receive events from your custom applications and services, or it can be a partner
event bus which can be matched to a partner event source.
# Arguments
- `name`: The name of the new event bus. Event bus names cannot contain the / character.
You can't use the name default for a custom event bus, as this name is already used for
your account's default event bus. If this is a partner event bus, the name must exactly
match the name of the partner event source that this event bus is matched to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventSourceName"`: If you are creating a partner event bus, this specifies the partner
event source that the new event bus will be matched with.
- `"Tags"`: Tags to associate with the event bus.
"""
function create_event_bus(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"CreateEventBus",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_event_bus(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"CreateEventBus",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_partner_event_source(account, name)
create_partner_event_source(account, name, params::Dict{String,<:Any})
Called by an SaaS partner to create a partner event source. This operation is not used by
Amazon Web Services customers. Each partner event source can be used by one Amazon Web
Services account to create a matching partner event bus in that Amazon Web Services
account. A SaaS partner must create one partner event source for each Amazon Web Services
account that wants to receive those event types. A partner event source creates events
based on resources within the SaaS partner's service or application. An Amazon Web Services
account that creates a partner event bus that matches the partner event source can use that
event bus to receive events from the partner, and then process them using Amazon Web
Services Events rules and targets. Partner event source names follow this format:
partner_name/event_namespace/event_name partner_name is determined during partner
registration and identifies the partner to Amazon Web Services customers. event_namespace
is determined by the partner and is a way for the partner to categorize their events.
event_name is determined by the partner, and should uniquely identify an event-generating
resource within the partner system. The combination of event_namespace and event_name
should help Amazon Web Services customers decide whether to create an event bus to receive
these events.
# Arguments
- `account`: The Amazon Web Services account ID that is permitted to create a matching
partner event bus for this partner event source.
- `name`: The name of the partner event source. This name must be unique and must be in the
format partner_name/event_namespace/event_name . The Amazon Web Services account that
wants to use this partner event source must create a partner event bus with a name that
matches the name of the partner event source.
"""
function create_partner_event_source(
Account, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"CreatePartnerEventSource",
Dict{String,Any}("Account" => Account, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_partner_event_source(
Account,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"CreatePartnerEventSource",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Account" => Account, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deactivate_event_source(name)
deactivate_event_source(name, params::Dict{String,<:Any})
You can use this operation to temporarily stop receiving events from the specified partner
event source. The matching event bus is not deleted. When you deactivate a partner event
source, the source goes into PENDING state. If it remains in PENDING state for more than
two weeks, it is deleted. To activate a deactivated partner event source, use
ActivateEventSource.
# Arguments
- `name`: The name of the partner event source to deactivate.
"""
function deactivate_event_source(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeactivateEventSource",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deactivate_event_source(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeactivateEventSource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deauthorize_connection(name)
deauthorize_connection(name, params::Dict{String,<:Any})
Removes all authorization parameters from the connection. This lets you remove the secret
from the connection so you can reuse it without having to create a new connection.
# Arguments
- `name`: The name of the connection to remove authorization from.
"""
function deauthorize_connection(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeauthorizeConnection",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deauthorize_connection(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeauthorizeConnection",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_api_destination(name)
delete_api_destination(name, params::Dict{String,<:Any})
Deletes the specified API destination.
# Arguments
- `name`: The name of the destination to delete.
"""
function delete_api_destination(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeleteApiDestination",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_api_destination(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeleteApiDestination",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_archive(archive_name)
delete_archive(archive_name, params::Dict{String,<:Any})
Deletes the specified archive.
# Arguments
- `archive_name`: The name of the archive to delete.
"""
function delete_archive(ArchiveName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeleteArchive",
Dict{String,Any}("ArchiveName" => ArchiveName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_archive(
ArchiveName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"DeleteArchive",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ArchiveName" => ArchiveName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_connection(name)
delete_connection(name, params::Dict{String,<:Any})
Deletes a connection.
# Arguments
- `name`: The name of the connection to delete.
"""
function delete_connection(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeleteConnection",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_connection(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeleteConnection",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_event_bus(name)
delete_event_bus(name, params::Dict{String,<:Any})
Deletes the specified custom event bus or partner event bus. All rules associated with this
event bus need to be deleted. You can't delete your account's default event bus.
# Arguments
- `name`: The name of the event bus to delete.
"""
function delete_event_bus(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeleteEventBus",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_event_bus(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeleteEventBus",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_partner_event_source(account, name)
delete_partner_event_source(account, name, params::Dict{String,<:Any})
This operation is used by SaaS partners to delete a partner event source. This operation is
not used by Amazon Web Services customers. When you delete an event source, the status of
the corresponding partner event bus in the Amazon Web Services customer account becomes
DELETED.
# Arguments
- `account`: The Amazon Web Services account ID of the Amazon Web Services customer that
the event source was created for.
- `name`: The name of the event source to delete.
"""
function delete_partner_event_source(
Account, Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeletePartnerEventSource",
Dict{String,Any}("Account" => Account, "Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_partner_event_source(
Account,
Name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"DeletePartnerEventSource",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Account" => Account, "Name" => Name), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_rule(name)
delete_rule(name, params::Dict{String,<:Any})
Deletes the specified rule. Before you can delete the rule, you must remove all targets,
using RemoveTargets. When you delete a rule, incoming events might continue to match to the
deleted rule. Allow a short period of time for changes to take effect. If you call delete
rule multiple times for the same rule, all calls will succeed. When you call delete rule
for a non-existent custom eventbus, ResourceNotFoundException is returned. Managed rules
are rules created and managed by another Amazon Web Services service on your behalf. These
rules are created by those other Amazon Web Services services to support functionality in
those services. You can delete these rules using the Force option, but you should do so
only if you are sure the other service is not still using that rule.
# Arguments
- `name`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
- `"Force"`: If this is a managed rule, created by an Amazon Web Services service on your
behalf, you must specify Force as True to delete the rule. This parameter is ignored for
rules that are not managed rules. You can check whether a rule is a managed rule by using
DescribeRule or ListRules and checking the ManagedBy field of the response.
"""
function delete_rule(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DeleteRule",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_rule(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DeleteRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_api_destination(name)
describe_api_destination(name, params::Dict{String,<:Any})
Retrieves details about an API destination.
# Arguments
- `name`: The name of the API destination to retrieve.
"""
function describe_api_destination(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeApiDestination",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_api_destination(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribeApiDestination",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_archive(archive_name)
describe_archive(archive_name, params::Dict{String,<:Any})
Retrieves details about an archive.
# Arguments
- `archive_name`: The name of the archive to retrieve.
"""
function describe_archive(ArchiveName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeArchive",
Dict{String,Any}("ArchiveName" => ArchiveName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_archive(
ArchiveName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"DescribeArchive",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ArchiveName" => ArchiveName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_connection(name)
describe_connection(name, params::Dict{String,<:Any})
Retrieves details about a connection.
# Arguments
- `name`: The name of the connection to retrieve.
"""
function describe_connection(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeConnection",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_connection(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribeConnection",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_event_bus()
describe_event_bus(params::Dict{String,<:Any})
Displays details about an event bus in your account. This can include the external Amazon
Web Services accounts that are permitted to write events to your default event bus, and the
associated policy. For custom event buses and partner event buses, it displays the name,
ARN, policy, state, and creation time. To enable your account to receive events from other
accounts on its default event bus, use PutPermission. For more information about partner
event buses, see CreateEventBus.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Name"`: The name or ARN of the event bus to show details for. If you omit this, the
default event bus is displayed.
"""
function describe_event_bus(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeEventBus"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_event_bus(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribeEventBus", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_event_source(name)
describe_event_source(name, params::Dict{String,<:Any})
This operation lists details about a partner event source that is shared with your account.
# Arguments
- `name`: The name of the partner event source to display the details of.
"""
function describe_event_source(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeEventSource",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_event_source(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribeEventSource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_partner_event_source(name)
describe_partner_event_source(name, params::Dict{String,<:Any})
An SaaS partner can use this operation to list details about a partner event source that
they have created. Amazon Web Services customers do not use this operation. Instead, Amazon
Web Services customers can use DescribeEventSource to see details about a partner event
source that is shared with them.
# Arguments
- `name`: The name of the event source to display.
"""
function describe_partner_event_source(
Name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribePartnerEventSource",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_partner_event_source(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribePartnerEventSource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_replay(replay_name)
describe_replay(replay_name, params::Dict{String,<:Any})
Retrieves details about a replay. Use DescribeReplay to determine the progress of a running
replay. A replay processes events to replay based on the time in the event, and replays
them using 1 minute intervals. If you use StartReplay and specify an EventStartTime and an
EventEndTime that covers a 20 minute time range, the events are replayed from the first
minute of that 20 minute range first. Then the events from the second minute are replayed.
You can use DescribeReplay to determine the progress of a replay. The value returned for
EventLastReplayedTime indicates the time within the specified time range associated with
the last event replayed.
# Arguments
- `replay_name`: The name of the replay to retrieve.
"""
function describe_replay(ReplayName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeReplay",
Dict{String,Any}("ReplayName" => ReplayName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_replay(
ReplayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"DescribeReplay",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ReplayName" => ReplayName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_rule(name)
describe_rule(name, params::Dict{String,<:Any})
Describes the specified rule. DescribeRule does not list the targets of a rule. To see the
targets associated with a rule, use ListTargetsByRule.
# Arguments
- `name`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
"""
function describe_rule(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DescribeRule",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_rule(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DescribeRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_rule(name)
disable_rule(name, params::Dict{String,<:Any})
Disables the specified rule. A disabled rule won't match any events, and won't self-trigger
if it has a schedule expression. When you disable a rule, incoming events might continue to
match to the disabled rule. Allow a short period of time for changes to take effect.
# Arguments
- `name`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
"""
function disable_rule(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"DisableRule",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_rule(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"DisableRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_rule(name)
enable_rule(name, params::Dict{String,<:Any})
Enables the specified rule. If the rule does not exist, the operation fails. When you
enable a rule, incoming events might not immediately start matching to a newly enabled
rule. Allow a short period of time for changes to take effect.
# Arguments
- `name`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
"""
function enable_rule(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"EnableRule",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_rule(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"EnableRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_api_destinations()
list_api_destinations(params::Dict{String,<:Any})
Retrieves a list of API destination in the account in the current Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConnectionArn"`: The ARN of the connection specified for the API destination.
- `"Limit"`: The maximum number of API destinations to include in the response.
- `"NamePrefix"`: A name prefix to filter results returned. Only API destinations with a
name that starts with the prefix are returned.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_api_destinations(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListApiDestinations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_api_destinations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListApiDestinations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_archives()
list_archives(params::Dict{String,<:Any})
Lists your archives. You can either list all the archives or you can provide a prefix to
match to the archive names. Filter parameters are exclusive.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventSourceArn"`: The ARN of the event source associated with the archive.
- `"Limit"`: The maximum number of results to return.
- `"NamePrefix"`: A name prefix to filter the archives returned. Only archives with name
that match the prefix are returned.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
- `"State"`: The state of the archive.
"""
function list_archives(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListArchives"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_archives(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListArchives", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_connections()
list_connections(params::Dict{String,<:Any})
Retrieves a list of connections from the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConnectionState"`: The state of the connection.
- `"Limit"`: The maximum number of connections to return.
- `"NamePrefix"`: A name prefix to filter results returned. Only connections with a name
that starts with the prefix are returned.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_connections(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListConnections"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_connections(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListConnections", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_event_buses()
list_event_buses(params::Dict{String,<:Any})
Lists all the event buses in your account, including the default event bus, custom event
buses, and partner event buses.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Limit"`: Specifying this limits the number of results returned by this operation. The
operation also returns a NextToken which you can use in a subsequent operation to retrieve
the next set of results.
- `"NamePrefix"`: Specifying this limits the results to only those event buses with names
that start with the specified prefix.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_event_buses(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListEventBuses"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_event_buses(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListEventBuses", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_event_sources()
list_event_sources(params::Dict{String,<:Any})
You can use this to see all the partner event sources that have been shared with your
Amazon Web Services account. For more information about partner event sources, see
CreateEventBus.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Limit"`: Specifying this limits the number of results returned by this operation. The
operation also returns a NextToken which you can use in a subsequent operation to retrieve
the next set of results.
- `"NamePrefix"`: Specifying this limits the results to only those partner event sources
with names that start with the specified prefix.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_event_sources(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListEventSources"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_event_sources(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListEventSources", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_partner_event_source_accounts(event_source_name)
list_partner_event_source_accounts(event_source_name, params::Dict{String,<:Any})
An SaaS partner can use this operation to display the Amazon Web Services account ID that a
particular partner event source name is associated with. This operation is not used by
Amazon Web Services customers.
# Arguments
- `event_source_name`: The name of the partner event source to display account information
about.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Limit"`: Specifying this limits the number of results returned by this operation. The
operation also returns a NextToken which you can use in a subsequent operation to retrieve
the next set of results.
- `"NextToken"`: The token returned by a previous call to this operation. Specifying this
retrieves the next set of results.
"""
function list_partner_event_source_accounts(
EventSourceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListPartnerEventSourceAccounts",
Dict{String,Any}("EventSourceName" => EventSourceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_partner_event_source_accounts(
EventSourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"ListPartnerEventSourceAccounts",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("EventSourceName" => EventSourceName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_partner_event_sources(name_prefix)
list_partner_event_sources(name_prefix, params::Dict{String,<:Any})
An SaaS partner can use this operation to list all the partner event source names that they
have created. This operation is not used by Amazon Web Services customers.
# Arguments
- `name_prefix`: If you specify this, the results are limited to only those partner event
sources that start with the string you specify.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Limit"`: pecifying this limits the number of results returned by this operation. The
operation also returns a NextToken which you can use in a subsequent operation to retrieve
the next set of results.
- `"NextToken"`: The token returned by a previous call to this operation. Specifying this
retrieves the next set of results.
"""
function list_partner_event_sources(
NamePrefix; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListPartnerEventSources",
Dict{String,Any}("NamePrefix" => NamePrefix);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_partner_event_sources(
NamePrefix,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"ListPartnerEventSources",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("NamePrefix" => NamePrefix), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_replays()
list_replays(params::Dict{String,<:Any})
Lists your replays. You can either list all the replays or you can provide a prefix to
match to the replay names. Filter parameters are exclusive.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventSourceArn"`: The ARN of the archive from which the events are replayed.
- `"Limit"`: The maximum number of replays to retrieve.
- `"NamePrefix"`: A name prefix to filter the replays returned. Only replays with name that
match the prefix are returned.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
- `"State"`: The state of the replay.
"""
function list_replays(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListReplays"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_replays(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListReplays", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_rule_names_by_target(target_arn)
list_rule_names_by_target(target_arn, params::Dict{String,<:Any})
Lists the rules for the specified target. You can see which of the rules in Amazon
EventBridge can invoke a specific target in your account.
# Arguments
- `target_arn`: The Amazon Resource Name (ARN) of the target resource.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus to list rules for. If you omit this,
the default event bus is used.
- `"Limit"`: The maximum number of results to return.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_rule_names_by_target(
TargetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListRuleNamesByTarget",
Dict{String,Any}("TargetArn" => TargetArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_rule_names_by_target(
TargetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"ListRuleNamesByTarget",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("TargetArn" => TargetArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_rules()
list_rules(params::Dict{String,<:Any})
Lists your Amazon EventBridge rules. You can either list all the rules or you can provide a
prefix to match to the rule names. ListRules does not list the targets of a rule. To see
the targets associated with a rule, use ListTargetsByRule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus to list the rules for. If you omit
this, the default event bus is used.
- `"Limit"`: The maximum number of results to return.
- `"NamePrefix"`: The prefix matching the rule name.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_rules(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListRules"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_rules(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListRules", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Displays the tags associated with an EventBridge resource. In EventBridge, rules and event
buses can be tagged.
# Arguments
- `resource_arn`: The ARN of the EventBridge resource for which you want to view tags.
"""
function list_tags_for_resource(
ResourceARN; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListTagsForResource",
Dict{String,Any}("ResourceARN" => ResourceARN);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceARN,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceARN" => ResourceARN), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_targets_by_rule(rule)
list_targets_by_rule(rule, params::Dict{String,<:Any})
Lists the targets assigned to the specified rule.
# Arguments
- `rule`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
- `"Limit"`: The maximum number of results to return.
- `"NextToken"`: The token returned by a previous call to retrieve the next set of results.
"""
function list_targets_by_rule(Rule; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"ListTargetsByRule",
Dict{String,Any}("Rule" => Rule);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_targets_by_rule(
Rule, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"ListTargetsByRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Rule" => Rule), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_events(entries)
put_events(entries, params::Dict{String,<:Any})
Sends custom events to Amazon EventBridge so that they can be matched to rules.
# Arguments
- `entries`: The entry that defines an event in your system. You can specify several
parameters for the entry such as the source and type of the event, resources associated
with the event, and so on.
"""
function put_events(Entries; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"PutEvents",
Dict{String,Any}("Entries" => Entries);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_events(
Entries, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"PutEvents",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Entries" => Entries), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_partner_events(entries)
put_partner_events(entries, params::Dict{String,<:Any})
This is used by SaaS partners to write events to a customer's partner event bus. Amazon Web
Services customers do not use this operation.
# Arguments
- `entries`: The list of events to write to the event bus.
"""
function put_partner_events(Entries; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"PutPartnerEvents",
Dict{String,Any}("Entries" => Entries);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_partner_events(
Entries, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"PutPartnerEvents",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Entries" => Entries), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_permission()
put_permission(params::Dict{String,<:Any})
Running PutPermission permits the specified Amazon Web Services account or Amazon Web
Services organization to put events to the specified event bus. Amazon EventBridge
(CloudWatch Events) rules in your account are triggered by these events arriving to an
event bus in your account. For another account to send events to your account, that
external account must have an EventBridge rule with your account's event bus as a target.
To enable multiple Amazon Web Services accounts to put events to your event bus, run
PutPermission once for each of these accounts. Or, if all the accounts are members of the
same Amazon Web Services organization, you can run PutPermission once specifying Principal
as \"*\" and specifying the Amazon Web Services organization ID in Condition, to grant
permissions to all accounts in that organization. If you grant permissions using an
organization, then accounts in that organization must specify a RoleArn with proper
permissions when they use PutTarget to add your account's event bus as a target. For more
information, see Sending and Receiving Events Between Amazon Web Services Accounts in the
Amazon EventBridge User Guide. The permission policy on the event bus cannot exceed 10 KB
in size.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Action"`: The action that you are enabling the other account to perform.
- `"Condition"`: This parameter enables you to limit the permission to accounts that
fulfill a certain condition, such as being a member of a certain Amazon Web Services
organization. For more information about Amazon Web Services Organizations, see What Is
Amazon Web Services Organizations in the Amazon Web Services Organizations User Guide. If
you specify Condition with an Amazon Web Services organization ID, and specify \"*\" as the
value for Principal, you grant permission to all the accounts in the named organization.
The Condition is a JSON string which must contain Type, Key, and Value fields.
- `"EventBusName"`: The name of the event bus associated with the rule. If you omit this,
the default event bus is used.
- `"Policy"`: A JSON string that describes the permission policy statement. You can include
a Policy parameter in the request instead of using the StatementId, Action, Principal, or
Condition parameters.
- `"Principal"`: The 12-digit Amazon Web Services account ID that you are permitting to put
events to your default event bus. Specify \"*\" to permit any account to put events to your
default event bus. If you specify \"*\" without specifying Condition, avoid creating rules
that may match undesirable events. To create more secure rules, make sure that the event
pattern for each rule contains an account field with a specific account ID from which to
receive events. Rules with an account field do not match any events sent from other
accounts.
- `"StatementId"`: An identifier string for the external account that you are granting
permissions to. If you later want to revoke the permission for this external account,
specify this StatementId when you run RemovePermission.
"""
function put_permission(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"PutPermission"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function put_permission(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"PutPermission", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_rule(name)
put_rule(name, params::Dict{String,<:Any})
Creates or updates the specified rule. Rules are enabled by default, or based on value of
the state. You can disable a rule using DisableRule. A single rule watches for events from
a single event bus. Events generated by Amazon Web Services services go to your account's
default event bus. Events generated by SaaS partner services or applications go to the
matching partner event bus. If you have custom applications or services, you can specify
whether their events go to your default event bus or a custom event bus that you have
created. For more information, see CreateEventBus. If you are updating an existing rule,
the rule is replaced with what you specify in this PutRule command. If you omit arguments
in PutRule, the old values for those arguments are not kept. Instead, they are replaced
with null values. When you create or update a rule, incoming events might not immediately
start matching to new or updated rules. Allow a short period of time for changes to take
effect. A rule must contain at least an EventPattern or ScheduleExpression. Rules with
EventPatterns are triggered when a matching event is observed. Rules with
ScheduleExpressions self-trigger based on the given schedule. A rule can have both an
EventPattern and a ScheduleExpression, in which case the rule triggers on matching events
as well as on a schedule. When you initially create a rule, you can optionally assign one
or more tags to the rule. Tags can help you organize and categorize your resources. You can
also use them to scope user permissions, by granting a user permission to access or change
only rules with certain tag values. To use the PutRule operation and assign tags, you must
have both the events:PutRule and events:TagResource permissions. If you are updating an
existing rule, any tags you specify in the PutRule operation are ignored. To update the
tags of an existing rule, use TagResource and UntagResource. Most services in Amazon Web
Services treat : or / as the same character in Amazon Resource Names (ARNs). However,
EventBridge uses an exact match in event patterns and rules. Be sure to use the correct ARN
characters when creating event patterns so that they match the ARN syntax in the event you
want to match. In EventBridge, it is possible to create rules that lead to infinite loops,
where a rule is fired repeatedly. For example, a rule might detect that ACLs have changed
on an S3 bucket, and trigger software to change them to the desired state. If the rule is
not written carefully, the subsequent change to the ACLs fires the rule again, creating an
infinite loop. To prevent this, write the rules so that the triggered actions do not
re-fire the same rule. For example, your rule could fire only if ACLs are found to be in a
bad state, instead of after any change. An infinite loop can quickly cause higher than
expected charges. We recommend that you use budgeting, which alerts you when charges exceed
your specified limit. For more information, see Managing Your Costs with Budgets.
# Arguments
- `name`: The name of the rule that you are creating or updating.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description of the rule.
- `"EventBusName"`: The name or ARN of the event bus to associate with this rule. If you
omit this, the default event bus is used.
- `"EventPattern"`: The event pattern. For more information, see Events and Event Patterns
in the Amazon EventBridge User Guide.
- `"RoleArn"`: The Amazon Resource Name (ARN) of the IAM role associated with the rule. If
you're setting an event bus in another account as the target and that account granted
permission to your account through an organization instead of directly by the account ID,
you must specify a RoleArn with proper permissions in the Target structure, instead of here
in this parameter.
- `"ScheduleExpression"`: The scheduling expression. For example, \"cron(0 20 * * ? *)\" or
\"rate(5 minutes)\".
- `"State"`: Indicates whether the rule is enabled or disabled.
- `"Tags"`: The list of key-value pairs to associate with the rule.
"""
function put_rule(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"PutRule",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_rule(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"PutRule",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_targets(rule, targets)
put_targets(rule, targets, params::Dict{String,<:Any})
Adds the specified targets to the specified rule, or updates the targets if they are
already associated with the rule. Targets are the resources that are invoked when a rule is
triggered. You can configure the following as targets for Events: API destination
Amazon API Gateway REST API endpoints API Gateway Batch job queue CloudWatch Logs
group CodeBuild project CodePipeline Amazon EC2 CreateSnapshot API call Amazon EC2
RebootInstances API call Amazon EC2 StopInstances API call Amazon EC2
TerminateInstances API call Amazon ECS tasks Event bus in a different Amazon Web
Services account or Region. You can use an event bus in the US East (N. Virginia)
us-east-1, US West (Oregon) us-west-2, or Europe (Ireland) eu-west-1 Regions as a target
for a rule. Firehose delivery stream (Kinesis Data Firehose) Inspector assessment
template (Amazon Inspector) Kinesis stream (Kinesis Data Stream) Lambda function
Redshift clusters (Data API statement execution) Amazon SNS topic Amazon SQS queues
(includes FIFO queues SSM Automation SSM OpsItem SSM Run Command Step Functions
state machines Creating rules with built-in targets is supported only in the Amazon Web
Services Management Console. The built-in targets are EC2 CreateSnapshot API call, EC2
RebootInstances API call, EC2 StopInstances API call, and EC2 TerminateInstances API call.
For some target types, PutTargets provides target-specific parameters. If the target is a
Kinesis data stream, you can optionally specify which shard the event goes to by using the
KinesisParameters argument. To invoke a command on multiple EC2 instances with one rule,
you can use the RunCommandParameters field. To be able to make API calls against the
resources that you own, Amazon EventBridge needs the appropriate permissions. For Lambda
and Amazon SNS resources, EventBridge relies on resource-based policies. For EC2 instances,
Kinesis Data Streams, Step Functions state machines and API Gateway REST APIs, EventBridge
relies on IAM roles that you specify in the RoleARN argument in PutTargets. For more
information, see Authentication and Access Control in the Amazon EventBridge User Guide. If
another Amazon Web Services account is in the same region and has granted you permission
(using PutPermission), you can send events to that account. Set that account's event bus as
a target of the rules in your account. To send the matched events to the other account,
specify that account's event bus as the Arn value when you run PutTargets. If your account
sends events to another account, your account is charged for each sent event. Each event
sent to another account is charged as a custom event. The account receiving the event is
not charged. For more information, see Amazon EventBridge Pricing. Input, InputPath, and
InputTransformer are not available with PutTarget if the target is an event bus of a
different Amazon Web Services account. If you are setting the event bus of another account
as the target, and that account granted permission to your account through an organization
instead of directly by the account ID, then you must specify a RoleArn with proper
permissions in the Target structure. For more information, see Sending and Receiving Events
Between Amazon Web Services Accounts in the Amazon EventBridge User Guide. For more
information about enabling cross-account events, see PutPermission. Input, InputPath, and
InputTransformer are mutually exclusive and optional parameters of a target. When a rule is
triggered due to a matched event: If none of the following arguments are specified for a
target, then the entire event is passed to the target in JSON format (unless the target is
Amazon EC2 Run Command or Amazon ECS task, in which case nothing from the event is passed
to the target). If Input is specified in the form of valid JSON, then the matched event
is overridden with this constant. If InputPath is specified in the form of JSONPath (for
example, .detail), then only the part of the event specified in the path is passed to the
target (for example, only the detail part of the event is passed). If InputTransformer is
specified, then one or more specified JSONPaths are extracted from the event and used as
values in a template that you specify as the input to the target. When you specify
InputPath or InputTransformer, you must use JSON dot notation, not bracket notation. When
you add targets to a rule and the associated rule triggers soon after, new or updated
targets might not be immediately invoked. Allow a short period of time for changes to take
effect. This action can partially fail if too many requests are made at the same time. If
that happens, FailedEntryCount is non-zero in the response and each entry in FailedEntries
provides the ID of the failed target and the error code.
# Arguments
- `rule`: The name of the rule.
- `targets`: The targets to update or add to the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
"""
function put_targets(Rule, Targets; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"PutTargets",
Dict{String,Any}("Rule" => Rule, "Targets" => Targets);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_targets(
Rule,
Targets,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"PutTargets",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("Rule" => Rule, "Targets" => Targets), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_permission()
remove_permission(params::Dict{String,<:Any})
Revokes the permission of another Amazon Web Services account to be able to put events to
the specified event bus. Specify the account to revoke by the StatementId value that you
associated with the account when you granted it permission with PutPermission. You can find
the StatementId by using DescribeEventBus.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name of the event bus to revoke permissions for. If you omit this,
the default event bus is used.
- `"RemoveAllPermissions"`: Specifies whether to remove all permissions.
- `"StatementId"`: The statement ID corresponding to the account that is no longer allowed
to put events to the default event bus.
"""
function remove_permission(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"RemovePermission"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function remove_permission(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"RemovePermission", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
remove_targets(ids, rule)
remove_targets(ids, rule, params::Dict{String,<:Any})
Removes the specified targets from the specified rule. When the rule is triggered, those
targets are no longer be invoked. When you remove a target, when the associated rule
triggers, removed targets might continue to be invoked. Allow a short period of time for
changes to take effect. This action can partially fail if too many requests are made at the
same time. If that happens, FailedEntryCount is non-zero in the response and each entry in
FailedEntries provides the ID of the failed target and the error code.
# Arguments
- `ids`: The IDs of the targets to remove from the rule.
- `rule`: The name of the rule.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EventBusName"`: The name or ARN of the event bus associated with the rule. If you omit
this, the default event bus is used.
- `"Force"`: If this is a managed rule, created by an Amazon Web Services service on your
behalf, you must specify Force as True to remove targets. This parameter is ignored for
rules that are not managed rules. You can check whether a rule is a managed rule by using
DescribeRule or ListRules and checking the ManagedBy field of the response.
"""
function remove_targets(Ids, Rule; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"RemoveTargets",
Dict{String,Any}("Ids" => Ids, "Rule" => Rule);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_targets(
Ids,
Rule,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"RemoveTargets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("Ids" => Ids, "Rule" => Rule), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_replay(destination, event_end_time, event_source_arn, event_start_time, replay_name)
start_replay(destination, event_end_time, event_source_arn, event_start_time, replay_name, params::Dict{String,<:Any})
Starts the specified replay. Events are not necessarily replayed in the exact same order
that they were added to the archive. A replay processes events to replay based on the time
in the event, and replays them using 1 minute intervals. If you specify an EventStartTime
and an EventEndTime that covers a 20 minute time range, the events are replayed from the
first minute of that 20 minute range first. Then the events from the second minute are
replayed. You can use DescribeReplay to determine the progress of a replay. The value
returned for EventLastReplayedTime indicates the time within the specified time range
associated with the last event replayed.
# Arguments
- `destination`: A ReplayDestination object that includes details about the destination for
the replay.
- `event_end_time`: A time stamp for the time to stop replaying events. Only events that
occurred between the EventStartTime and EventEndTime are replayed.
- `event_source_arn`: The ARN of the archive to replay events from.
- `event_start_time`: A time stamp for the time to start replaying events. Only events that
occurred between the EventStartTime and EventEndTime are replayed.
- `replay_name`: The name of the replay to start.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: A description for the replay to start.
"""
function start_replay(
Destination,
EventEndTime,
EventSourceArn,
EventStartTime,
ReplayName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"StartReplay",
Dict{String,Any}(
"Destination" => Destination,
"EventEndTime" => EventEndTime,
"EventSourceArn" => EventSourceArn,
"EventStartTime" => EventStartTime,
"ReplayName" => ReplayName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_replay(
Destination,
EventEndTime,
EventSourceArn,
EventStartTime,
ReplayName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"StartReplay",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Destination" => Destination,
"EventEndTime" => EventEndTime,
"EventSourceArn" => EventSourceArn,
"EventStartTime" => EventStartTime,
"ReplayName" => ReplayName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns one or more tags (key-value pairs) to the specified EventBridge resource. Tags can
help you organize and categorize your resources. You can also use them to scope user
permissions by granting a user permission to access or change only resources with certain
tag values. In EventBridge, rules and event buses can be tagged. Tags don't have any
semantic meaning to Amazon Web Services and are interpreted strictly as strings of
characters. You can use the TagResource action with a resource that already has tags. If
you specify a new tag key, this tag is appended to the list of tags associated with the
resource. If you specify a tag key that is already associated with the resource, the new
tag value that you specify replaces the previous value for that tag. You can associate as
many as 50 tags with a resource.
# Arguments
- `resource_arn`: The ARN of the EventBridge resource that you're adding tags to.
- `tags`: The list of key-value pairs to associate with the resource.
"""
function tag_resource(ResourceARN, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"TagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceARN,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_event_pattern(event, event_pattern)
test_event_pattern(event, event_pattern, params::Dict{String,<:Any})
Tests whether the specified event pattern matches the provided event. Most services in
Amazon Web Services treat : or / as the same character in Amazon Resource Names (ARNs).
However, EventBridge uses an exact match in event patterns and rules. Be sure to use the
correct ARN characters when creating event patterns so that they match the ARN syntax in
the event you want to match.
# Arguments
- `event`: The event, in JSON format, to test against the event pattern. The JSON must
follow the format specified in Amazon Web Services Events, and the following fields are
mandatory: id account source time region resources detail-type
- `event_pattern`: The event pattern. For more information, see Events and Event Patterns
in the Amazon EventBridge User Guide.
"""
function test_event_pattern(
Event, EventPattern; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"TestEventPattern",
Dict{String,Any}("Event" => Event, "EventPattern" => EventPattern);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_event_pattern(
Event,
EventPattern,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"TestEventPattern",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("Event" => Event, "EventPattern" => EventPattern),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes one or more tags from the specified EventBridge resource. In Amazon EventBridge
(CloudWatch Events), rules and event buses can be tagged.
# Arguments
- `resource_arn`: The ARN of the EventBridge resource from which you are removing tags.
- `tag_keys`: The list of tag keys to remove from the resource.
"""
function untag_resource(
ResourceARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"UntagResource",
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceARN,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceARN" => ResourceARN, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_api_destination(name)
update_api_destination(name, params::Dict{String,<:Any})
Updates an API destination.
# Arguments
- `name`: The name of the API destination to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConnectionArn"`: The ARN of the connection to use for the API destination.
- `"Description"`: The name of the API destination to update.
- `"HttpMethod"`: The method to use for the API destination.
- `"InvocationEndpoint"`: The URL to the endpoint to use for the API destination.
- `"InvocationRateLimitPerSecond"`: The maximum number of invocations per second to send to
the API destination.
"""
function update_api_destination(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"UpdateApiDestination",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_api_destination(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"UpdateApiDestination",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_archive(archive_name)
update_archive(archive_name, params::Dict{String,<:Any})
Updates the specified archive.
# Arguments
- `archive_name`: The name of the archive to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Description"`: The description for the archive.
- `"EventPattern"`: The event pattern to use to filter events sent to the archive.
- `"RetentionDays"`: The number of days to retain events in the archive.
"""
function update_archive(ArchiveName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"UpdateArchive",
Dict{String,Any}("ArchiveName" => ArchiveName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_archive(
ArchiveName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_events(
"UpdateArchive",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ArchiveName" => ArchiveName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_connection(name)
update_connection(name, params::Dict{String,<:Any})
Updates settings for a connection.
# Arguments
- `name`: The name of the connection to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AuthParameters"`: The authorization parameters to use for the connection.
- `"AuthorizationType"`: The type of authorization to use for the connection.
- `"Description"`: A description for the connection.
"""
function update_connection(Name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_events(
"UpdateConnection",
Dict{String,Any}("Name" => Name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_connection(
Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_events(
"UpdateConnection",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Name" => Name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 157926 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: cloudwatch_logs
using AWS.Compat
using AWS.UUIDs
"""
associate_kms_key(kms_key_id)
associate_kms_key(kms_key_id, params::Dict{String,<:Any})
Associates the specified KMS key with either one log group in the account, or with all
stored CloudWatch Logs query insights results in the account. When you use AssociateKmsKey,
you specify either the logGroupName parameter or the resourceIdentifier parameter. You
can't specify both of those parameters in the same operation. Specify the logGroupName
parameter to cause all log events stored in the log group to be encrypted with that key.
Only the log events ingested after the key is associated are encrypted with that key.
Associating a KMS key with a log group overrides any existing associations between the log
group and a KMS key. After a KMS key is associated with a log group, all newly ingested
data for the log group is encrypted using the KMS key. This association is stored as long
as the data encrypted with the KMS key is still within CloudWatch Logs. This enables
CloudWatch Logs to decrypt this data whenever it is requested. Associating a key with a log
group does not cause the results of queries of that log group to be encrypted with that
key. To have query results encrypted with a KMS key, you must use an AssociateKmsKey
operation with the resourceIdentifier parameter that specifies a query-result resource.
Specify the resourceIdentifier parameter with a query-result resource, to use that key to
encrypt the stored results of all future StartQuery operations in the account. The response
from a GetQueryResults operation will still return the query results in plain text. Even if
you have not associated a key with your query results, the query results are encrypted when
stored, using the default CloudWatch Logs method. If you run a query from a monitoring
account that queries logs in a source account, the query results key from the monitoring
account, if any, is used. If you delete the key that is used to encrypt log events or
log group query results, then all the associated stored log events or query results that
were encrypted with that key will be unencryptable and unusable. CloudWatch Logs supports
only symmetric KMS keys. Do not use an associate an asymmetric KMS key with your log group
or query results. For more information, see Using Symmetric and Asymmetric Keys. It can
take up to 5 minutes for this operation to take effect. If you attempt to associate a KMS
key with a log group but the KMS key does not exist or the KMS key is disabled, you receive
an InvalidParameterException error.
# Arguments
- `kms_key_id`: The Amazon Resource Name (ARN) of the KMS key to use when encrypting log
data. This must be a symmetric KMS key. For more information, see Amazon Resource Names and
Using Symmetric and Asymmetric Keys.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"logGroupName"`: The name of the log group. In your AssociateKmsKey operation, you must
specify either the resourceIdentifier parameter or the logGroup parameter, but you can't
specify both.
- `"resourceIdentifier"`: Specifies the target for this operation. You must specify one of
the following: Specify the following ARN to have future GetQueryResults operations in
this account encrypt the results with the specified KMS key. Replace REGION and ACCOUNT_ID
with your Region and account ID. arn:aws:logs:REGION:ACCOUNT_ID:query-result:* Specify
the ARN of a log group to have CloudWatch Logs use the KMS key to encrypt log events that
are ingested and stored by that log group. The log group ARN must be in the following
format. Replace REGION and ACCOUNT_ID with your Region and account ID.
arn:aws:logs:REGION:ACCOUNT_ID:log-group:LOG_GROUP_NAME In your AssociateKmsKey
operation, you must specify either the resourceIdentifier parameter or the logGroup
parameter, but you can't specify both.
"""
function associate_kms_key(kmsKeyId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"AssociateKmsKey",
Dict{String,Any}("kmsKeyId" => kmsKeyId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_kms_key(
kmsKeyId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"AssociateKmsKey",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("kmsKeyId" => kmsKeyId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
cancel_export_task(task_id)
cancel_export_task(task_id, params::Dict{String,<:Any})
Cancels the specified export task. The task must be in the PENDING or RUNNING state.
# Arguments
- `task_id`: The ID of the export task.
"""
function cancel_export_task(taskId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"CancelExportTask",
Dict{String,Any}("taskId" => taskId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function cancel_export_task(
taskId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"CancelExportTask",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("taskId" => taskId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_delivery(delivery_destination_arn, delivery_source_name)
create_delivery(delivery_destination_arn, delivery_source_name, params::Dict{String,<:Any})
Creates a delivery. A delivery is a connection between a logical delivery source and a
logical delivery destination that you have already created. Only some Amazon Web Services
services support being configured as a delivery source using this operation. These services
are listed as Supported [V2 Permissions] in the table at Enabling logging from Amazon Web
Services services. A delivery destination can represent a log group in CloudWatch Logs, an
Amazon S3 bucket, or a delivery stream in Firehose. To configure logs delivery between a
supported Amazon Web Services service and a destination, you must do the following:
Create a delivery source, which is a logical object that represents the resource that is
actually sending the logs. For more information, see PutDeliverySource. Create a delivery
destination, which is a logical object that represents the actual delivery destination. For
more information, see PutDeliveryDestination. If you are delivering logs cross-account,
you must use PutDeliveryDestinationPolicy in the destination account to assign an IAM
policy to the destination. This policy allows delivery to that destination. Use
CreateDelivery to create a delivery by pairing exactly one delivery source and one delivery
destination. You can configure a single delivery source to send logs to multiple
destinations by creating multiple deliveries. You can also create multiple deliveries to
configure multiple delivery sources to send logs to the same delivery destination. You
can't update an existing delivery. You can only create and delete deliveries.
# Arguments
- `delivery_destination_arn`: The ARN of the delivery destination to use for this delivery.
- `delivery_source_name`: The name of the delivery source to use for this delivery.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: An optional list of key-value pairs to associate with the resource. For more
information about tagging, see Tagging Amazon Web Services resources
"""
function create_delivery(
deliveryDestinationArn,
deliverySourceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateDelivery",
Dict{String,Any}(
"deliveryDestinationArn" => deliveryDestinationArn,
"deliverySourceName" => deliverySourceName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_delivery(
deliveryDestinationArn,
deliverySourceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateDelivery",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"deliveryDestinationArn" => deliveryDestinationArn,
"deliverySourceName" => deliverySourceName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_export_task(destination, from, log_group_name, to)
create_export_task(destination, from, log_group_name, to, params::Dict{String,<:Any})
Creates an export task so that you can efficiently export data from a log group to an
Amazon S3 bucket. When you perform a CreateExportTask operation, you must use credentials
that have permission to write to the S3 bucket that you specify as the destination.
Exporting log data to S3 buckets that are encrypted by KMS is supported. Exporting log data
to Amazon S3 buckets that have S3 Object Lock enabled with a retention period is also
supported. Exporting to S3 buckets that are encrypted with AES-256 is supported. This is
an asynchronous call. If all the required information is provided, this operation initiates
an export task and responds with the ID of the task. After the task has started, you can
use DescribeExportTasks to get the status of the export task. Each account can only have
one active (RUNNING or PENDING) export task at a time. To cancel an export task, use
CancelExportTask. You can export logs from multiple log groups or multiple time ranges to
the same S3 bucket. To separate log data for each export task, specify a prefix to be used
as the Amazon S3 key prefix for all exported objects. Time-based sorting on chunks of log
data inside an exported file is not guaranteed. You can sort the exported log field data by
using Linux utilities.
# Arguments
- `destination`: The name of S3 bucket for the exported log data. The bucket must be in the
same Amazon Web Services Region.
- `from`: The start time of the range for the request, expressed as the number of
milliseconds after Jan 1, 1970 00:00:00 UTC. Events with a timestamp earlier than this time
are not exported.
- `log_group_name`: The name of the log group.
- `to`: The end time of the range for the request, expressed as the number of milliseconds
after Jan 1, 1970 00:00:00 UTC. Events with a timestamp later than this time are not
exported. You must specify a time that is not earlier than when this log group was created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"destinationPrefix"`: The prefix used as the start of the key for every object exported.
If you don't specify a value, the default is exportedlogs.
- `"logStreamNamePrefix"`: Export only log streams that match the provided prefix. If you
don't specify a value, no prefix filter is applied.
- `"taskName"`: The name of the export task.
"""
function create_export_task(
destination, from, logGroupName, to; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"CreateExportTask",
Dict{String,Any}(
"destination" => destination,
"from" => from,
"logGroupName" => logGroupName,
"to" => to,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_export_task(
destination,
from,
logGroupName,
to,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateExportTask",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destination" => destination,
"from" => from,
"logGroupName" => logGroupName,
"to" => to,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_log_anomaly_detector(log_group_arn_list)
create_log_anomaly_detector(log_group_arn_list, params::Dict{String,<:Any})
Creates an anomaly detector that regularly scans one or more log groups and look for
patterns and anomalies in the logs. An anomaly detector can help surface issues by
automatically discovering anomalies in your log event traffic. An anomaly detector uses
machine learning algorithms to scan log events and find patterns. A pattern is a shared
text structure that recurs among your log fields. Patterns provide a useful tool for
analyzing large sets of logs because a large number of log events can often be compressed
into a few patterns. The anomaly detector uses pattern recognition to find anomalies, which
are unusual log events. It uses the evaluationFrequency to compare current log events and
patterns with trained baselines. Fields within a pattern are called tokens. Fields that
vary within a pattern, such as a request ID or timestamp, are referred to as dynamic tokens
and represented by <*>. The following is an example of a pattern: [INFO] Request
time: <*> ms This pattern represents log events like [INFO] Request time: 327 ms and
other similar log events that differ only by the number, in this csse 327. When the pattern
is displayed, the different numbers are replaced by <*> Any parts of log events
that are masked as sensitive data are not scanned for anomalies. For more information about
masking sensitive data, see Help protect sensitive log data with masking.
# Arguments
- `log_group_arn_list`: An array containing the ARN of the log group that this anomaly
detector will watch. You can specify only one log group ARN.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"anomalyVisibilityTime"`: The number of days to have visibility on an anomaly. After
this time period has elapsed for an anomaly, it will be automatically baselined and the
anomaly detector will treat new occurrences of a similar anomaly as normal. Therefore, if
you do not correct the cause of an anomaly during the time period specified in
anomalyVisibilityTime, it will be considered normal going forward and will not be detected
as an anomaly.
- `"detectorName"`: A name for this anomaly detector.
- `"evaluationFrequency"`: Specifies how often the anomaly detector is to run and look for
anomalies. Set this value according to the frequency that the log group receives new logs.
For example, if the log group receives new log events every 10 minutes, then 15 minutes
might be a good setting for evaluationFrequency .
- `"filterPattern"`: You can use this parameter to limit the anomaly detection model to
examine only log events that match the pattern you specify here. For more information, see
Filter and Pattern Syntax.
- `"kmsKeyId"`: Optionally assigns a KMS key to secure this anomaly detector and its
findings. If a key is assigned, the anomalies found and the model used by this detector are
encrypted at rest with the key. If a key is assigned to an anomaly detector, a user must
have permissions for both this key and for the anomaly detector to retrieve information
about the anomalies that it finds. For more information about using a KMS key and to see
the required IAM policy, see Use a KMS key with an anomaly detector.
- `"tags"`: An optional list of key-value pairs to associate with the resource. For more
information about tagging, see Tagging Amazon Web Services resources
"""
function create_log_anomaly_detector(
logGroupArnList; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"CreateLogAnomalyDetector",
Dict{String,Any}("logGroupArnList" => logGroupArnList);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_log_anomaly_detector(
logGroupArnList,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateLogAnomalyDetector",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("logGroupArnList" => logGroupArnList), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_log_group(log_group_name)
create_log_group(log_group_name, params::Dict{String,<:Any})
Creates a log group with the specified name. You can create up to 1,000,000 log groups per
Region per account. You must use the following guidelines when naming a log group: Log
group names must be unique within a Region for an Amazon Web Services account. Log group
names can be between 1 and 512 characters long. Log group names consist of the following
characters: a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen), '/' (forward slash), '.'
(period), and '#' (number sign) Log group names can't start with the string aws/ When
you create a log group, by default the log events in the log group do not expire. To set a
retention policy so that events expire and are deleted after a specified time, use
PutRetentionPolicy. If you associate an KMS key with the log group, ingested data is
encrypted using the KMS key. This association is stored as long as the data encrypted with
the KMS key is still within CloudWatch Logs. This enables CloudWatch Logs to decrypt this
data whenever it is requested. If you attempt to associate a KMS key with the log group but
the KMS key does not exist or the KMS key is disabled, you receive an
InvalidParameterException error. CloudWatch Logs supports only symmetric KMS keys. Do not
associate an asymmetric KMS key with your log group. For more information, see Using
Symmetric and Asymmetric Keys.
# Arguments
- `log_group_name`: A name for the log group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"kmsKeyId"`: The Amazon Resource Name (ARN) of the KMS key to use when encrypting log
data. For more information, see Amazon Resource Names.
- `"logGroupClass"`: Use this parameter to specify the log group class for this log group.
There are two classes: The Standard log class supports all CloudWatch Logs features.
The Infrequent Access log class supports a subset of CloudWatch Logs features and incurs
lower costs. If you omit this parameter, the default of STANDARD is used. The value of
logGroupClass can't be changed after a log group is created. For details about the
features supported by each class, see Log classes
- `"tags"`: The key-value pairs to use for the tags. You can grant users access to certain
log groups while preventing them from accessing other log groups. To do so, tag your groups
and use IAM policies that refer to those tags. To assign tags when you create a log group,
you must have either the logs:TagResource or logs:TagLogGroup permission. For more
information about tagging, see Tagging Amazon Web Services resources. For more information
about using tags to control access, see Controlling access to Amazon Web Services resources
using tags.
"""
function create_log_group(logGroupName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"CreateLogGroup",
Dict{String,Any}("logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_log_group(
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateLogGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logGroupName" => logGroupName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_log_stream(log_group_name, log_stream_name)
create_log_stream(log_group_name, log_stream_name, params::Dict{String,<:Any})
Creates a log stream for the specified log group. A log stream is a sequence of log events
that originate from a single source, such as an application instance or a resource that is
being monitored. There is no limit on the number of log streams that you can create for a
log group. There is a limit of 50 TPS on CreateLogStream operations, after which
transactions are throttled. You must use the following guidelines when naming a log stream:
Log stream names must be unique within the log group. Log stream names can be between 1
and 512 characters long. Don't use ':' (colon) or '*' (asterisk) characters.
# Arguments
- `log_group_name`: The name of the log group.
- `log_stream_name`: The name of the log stream.
"""
function create_log_stream(
logGroupName, logStreamName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"CreateLogStream",
Dict{String,Any}("logGroupName" => logGroupName, "logStreamName" => logStreamName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_log_stream(
logGroupName,
logStreamName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"CreateLogStream",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupName" => logGroupName, "logStreamName" => logStreamName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_account_policy(policy_name, policy_type)
delete_account_policy(policy_name, policy_type, params::Dict{String,<:Any})
Deletes a CloudWatch Logs account policy. This stops the policy from applying to all log
groups or a subset of log groups in the account. Log-group level policies will still be in
effect. To use this operation, you must be signed on with the correct permissions depending
on the type of policy that you are deleting. To delete a data protection policy, you must
have the logs:DeleteDataProtectionPolicy and logs:DeleteAccountPolicy permissions. To
delete a subscription filter policy, you must have the logs:DeleteSubscriptionFilter and
logs:DeleteAccountPolicy permissions.
# Arguments
- `policy_name`: The name of the policy to delete.
- `policy_type`: The type of policy to delete.
"""
function delete_account_policy(
policyName, policyType; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteAccountPolicy",
Dict{String,Any}("policyName" => policyName, "policyType" => policyType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_account_policy(
policyName,
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteAccountPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("policyName" => policyName, "policyType" => policyType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_data_protection_policy(log_group_identifier)
delete_data_protection_policy(log_group_identifier, params::Dict{String,<:Any})
Deletes the data protection policy from the specified log group. For more information
about data protection policies, see PutDataProtectionPolicy.
# Arguments
- `log_group_identifier`: The name or ARN of the log group that you want to delete the data
protection policy for.
"""
function delete_data_protection_policy(
logGroupIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDataProtectionPolicy",
Dict{String,Any}("logGroupIdentifier" => logGroupIdentifier);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_data_protection_policy(
logGroupIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteDataProtectionPolicy",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("logGroupIdentifier" => logGroupIdentifier), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_delivery(id)
delete_delivery(id, params::Dict{String,<:Any})
Deletes s delivery. A delivery is a connection between a logical delivery source and a
logical delivery destination. Deleting a delivery only deletes the connection between the
delivery source and delivery destination. It does not delete the delivery destination or
the delivery source.
# Arguments
- `id`: The unique ID of the delivery to delete. You can find the ID of a delivery with the
DescribeDeliveries operation.
"""
function delete_delivery(id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DeleteDelivery",
Dict{String,Any}("id" => id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_delivery(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDelivery",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("id" => id), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_delivery_destination(name)
delete_delivery_destination(name, params::Dict{String,<:Any})
Deletes a delivery destination. A delivery is a connection between a logical delivery
source and a logical delivery destination. You can't delete a delivery destination if any
current deliveries are associated with it. To find whether any deliveries are associated
with this delivery destination, use the DescribeDeliveries operation and check the
deliveryDestinationArn field in the results.
# Arguments
- `name`: The name of the delivery destination that you want to delete. You can find a list
of delivery destionation names by using the DescribeDeliveryDestinations operation.
"""
function delete_delivery_destination(
name; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDeliveryDestination",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_delivery_destination(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDeliveryDestination",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_delivery_destination_policy(delivery_destination_name)
delete_delivery_destination_policy(delivery_destination_name, params::Dict{String,<:Any})
Deletes a delivery destination policy. For more information about these policies, see
PutDeliveryDestinationPolicy.
# Arguments
- `delivery_destination_name`: The name of the delivery destination that you want to delete
the policy for.
"""
function delete_delivery_destination_policy(
deliveryDestinationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDeliveryDestinationPolicy",
Dict{String,Any}("deliveryDestinationName" => deliveryDestinationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_delivery_destination_policy(
deliveryDestinationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteDeliveryDestinationPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deliveryDestinationName" => deliveryDestinationName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_delivery_source(name)
delete_delivery_source(name, params::Dict{String,<:Any})
Deletes a delivery source. A delivery is a connection between a logical delivery source and
a logical delivery destination. You can't delete a delivery source if any current
deliveries are associated with it. To find whether any deliveries are associated with this
delivery source, use the DescribeDeliveries operation and check the deliverySourceName
field in the results.
# Arguments
- `name`: The name of the delivery source that you want to delete.
"""
function delete_delivery_source(name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DeleteDeliverySource",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_delivery_source(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDeliverySource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_destination(destination_name)
delete_destination(destination_name, params::Dict{String,<:Any})
Deletes the specified destination, and eventually disables all the subscription filters
that publish to it. This operation does not delete the physical resource encapsulated by
the destination.
# Arguments
- `destination_name`: The name of the destination.
"""
function delete_destination(
destinationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteDestination",
Dict{String,Any}("destinationName" => destinationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_destination(
destinationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteDestination",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("destinationName" => destinationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_log_anomaly_detector(anomaly_detector_arn)
delete_log_anomaly_detector(anomaly_detector_arn, params::Dict{String,<:Any})
Deletes the specified CloudWatch Logs anomaly detector.
# Arguments
- `anomaly_detector_arn`: The ARN of the anomaly detector to delete. You can find the ARNs
of log anomaly detectors in your account by using the ListLogAnomalyDetectors operation.
"""
function delete_log_anomaly_detector(
anomalyDetectorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteLogAnomalyDetector",
Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_log_anomaly_detector(
anomalyDetectorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteLogAnomalyDetector",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_log_group(log_group_name)
delete_log_group(log_group_name, params::Dict{String,<:Any})
Deletes the specified log group and permanently deletes all the archived log events
associated with the log group.
# Arguments
- `log_group_name`: The name of the log group.
"""
function delete_log_group(logGroupName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DeleteLogGroup",
Dict{String,Any}("logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_log_group(
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteLogGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logGroupName" => logGroupName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_log_stream(log_group_name, log_stream_name)
delete_log_stream(log_group_name, log_stream_name, params::Dict{String,<:Any})
Deletes the specified log stream and permanently deletes all the archived log events
associated with the log stream.
# Arguments
- `log_group_name`: The name of the log group.
- `log_stream_name`: The name of the log stream.
"""
function delete_log_stream(
logGroupName, logStreamName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteLogStream",
Dict{String,Any}("logGroupName" => logGroupName, "logStreamName" => logStreamName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_log_stream(
logGroupName,
logStreamName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteLogStream",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupName" => logGroupName, "logStreamName" => logStreamName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_metric_filter(filter_name, log_group_name)
delete_metric_filter(filter_name, log_group_name, params::Dict{String,<:Any})
Deletes the specified metric filter.
# Arguments
- `filter_name`: The name of the metric filter.
- `log_group_name`: The name of the log group.
"""
function delete_metric_filter(
filterName, logGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteMetricFilter",
Dict{String,Any}("filterName" => filterName, "logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_metric_filter(
filterName,
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteMetricFilter",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filterName" => filterName, "logGroupName" => logGroupName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_query_definition(query_definition_id)
delete_query_definition(query_definition_id, params::Dict{String,<:Any})
Deletes a saved CloudWatch Logs Insights query definition. A query definition contains
details about a saved CloudWatch Logs Insights query. Each DeleteQueryDefinition operation
can delete one query definition. You must have the logs:DeleteQueryDefinition permission to
be able to perform this operation.
# Arguments
- `query_definition_id`: The ID of the query definition that you want to delete. You can
use DescribeQueryDefinitions to retrieve the IDs of your saved query definitions.
"""
function delete_query_definition(
queryDefinitionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteQueryDefinition",
Dict{String,Any}("queryDefinitionId" => queryDefinitionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_query_definition(
queryDefinitionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteQueryDefinition",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("queryDefinitionId" => queryDefinitionId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resource_policy()
delete_resource_policy(params::Dict{String,<:Any})
Deletes a resource policy from this account. This revokes the access of the identities in
that policy to put log events to this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"policyName"`: The name of the policy to be revoked. This parameter is required.
"""
function delete_resource_policy(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DeleteResourcePolicy"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function delete_resource_policy(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteResourcePolicy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_retention_policy(log_group_name)
delete_retention_policy(log_group_name, params::Dict{String,<:Any})
Deletes the specified retention policy. Log events do not expire if they belong to log
groups without a retention policy.
# Arguments
- `log_group_name`: The name of the log group.
"""
function delete_retention_policy(
logGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteRetentionPolicy",
Dict{String,Any}("logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_retention_policy(
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteRetentionPolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logGroupName" => logGroupName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_subscription_filter(filter_name, log_group_name)
delete_subscription_filter(filter_name, log_group_name, params::Dict{String,<:Any})
Deletes the specified subscription filter.
# Arguments
- `filter_name`: The name of the subscription filter.
- `log_group_name`: The name of the log group.
"""
function delete_subscription_filter(
filterName, logGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DeleteSubscriptionFilter",
Dict{String,Any}("filterName" => filterName, "logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_subscription_filter(
filterName,
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DeleteSubscriptionFilter",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filterName" => filterName, "logGroupName" => logGroupName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_account_policies(policy_type)
describe_account_policies(policy_type, params::Dict{String,<:Any})
Returns a list of all CloudWatch Logs account policies in the account.
# Arguments
- `policy_type`: Use this parameter to limit the returned policies to only the policies
that match the policy type that you specify.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accountIdentifiers"`: If you are using an account that is set up as a monitoring
account for CloudWatch unified cross-account observability, you can use this to specify the
account ID of a source account. If you do, the operation returns the account policy for the
specified account. Currently, you can specify only one account ID in this parameter. If you
omit this parameter, only the policy in the current account is returned.
- `"policyName"`: Use this parameter to limit the returned policies to only the policy with
the name that you specify.
"""
function describe_account_policies(
policyType; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeAccountPolicies",
Dict{String,Any}("policyType" => policyType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_account_policies(
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DescribeAccountPolicies",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("policyType" => policyType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_deliveries()
describe_deliveries(params::Dict{String,<:Any})
Retrieves a list of the deliveries that have been created in the account. A delivery is a
connection between a delivery source and a delivery destination . A delivery source
represents an Amazon Web Services resource that sends logs to an logs delivery destination.
The destination can be CloudWatch Logs, Amazon S3, or Firehose. Only some Amazon Web
Services services support being configured as a delivery source. These services are listed
in Enable logging from Amazon Web Services services.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: Optionally specify the maximum number of deliveries to return in the response.
- `"nextToken"`:
"""
function describe_deliveries(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeDeliveries"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_deliveries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeDeliveries", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_delivery_destinations()
describe_delivery_destinations(params::Dict{String,<:Any})
Retrieves a list of the delivery destinations that have been created in the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: Optionally specify the maximum number of delivery destinations to return in
the response.
- `"nextToken"`:
"""
function describe_delivery_destinations(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeDeliveryDestinations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_delivery_destinations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeDeliveryDestinations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_delivery_sources()
describe_delivery_sources(params::Dict{String,<:Any})
Retrieves a list of the delivery sources that have been created in the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: Optionally specify the maximum number of delivery sources to return in the
response.
- `"nextToken"`:
"""
function describe_delivery_sources(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeDeliverySources"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_delivery_sources(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeDeliverySources",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_destinations()
describe_destinations(params::Dict{String,<:Any})
Lists all your destinations. The results are ASCII-sorted by destination name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"DestinationNamePrefix"`: The prefix to match. If you don't specify a value, no prefix
filter is applied.
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default maximum value of 50 items is used.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_destinations(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeDestinations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_destinations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeDestinations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_export_tasks()
describe_export_tasks(params::Dict{String,<:Any})
Lists the specified export tasks. You can list all your export tasks or filter the results
based on task ID or task status.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default is up to 50 items.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"statusCode"`: The status code of the export task. Specifying a status code filters the
results to zero or more export tasks.
- `"taskId"`: The ID of the export task. Specifying a task ID filters the results to one or
zero export tasks.
"""
function describe_export_tasks(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeExportTasks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_export_tasks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeExportTasks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_log_groups()
describe_log_groups(params::Dict{String,<:Any})
Lists the specified log groups. You can list all your log groups or filter the results by
prefix. The results are ASCII-sorted by log group name. CloudWatch Logs doesn’t support
IAM policies that control access to the DescribeLogGroups action by using the
aws:ResourceTag/key-name condition key. Other CloudWatch Logs actions do support the use
of the aws:ResourceTag/key-name condition key to control access. For more information
about using tags to control access, see Controlling access to Amazon Web Services resources
using tags. If you are using CloudWatch cross-account observability, you can use this
operation in a monitoring account and view data from the linked source accounts. For more
information, see CloudWatch cross-account observability.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"accountIdentifiers"`: When includeLinkedAccounts is set to True, use this parameter to
specify the list of accounts to search. You can specify as many as 20 account IDs in the
array.
- `"includeLinkedAccounts"`: If you are using a monitoring account, set this to True to
have the operation return log groups in the accounts listed in accountIdentifiers. If this
parameter is set to true and accountIdentifiers contains a null value, the operation
returns all log groups in the monitoring account and all log groups in all source accounts
that are linked to the monitoring account.
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default is up to 50 items.
- `"logGroupClass"`: Specifies the log group class for this log group. There are two
classes: The Standard log class supports all CloudWatch Logs features. The Infrequent
Access log class supports a subset of CloudWatch Logs features and incurs lower costs.
For details about the features supported by each class, see Log classes
- `"logGroupNamePattern"`: If you specify a string for this parameter, the operation
returns only log groups that have names that match the string based on a case-sensitive
substring search. For example, if you specify Foo, log groups named FooBar, aws/Foo, and
GroupFoo would match, but foo, F/o/o and Froo would not match. If you specify
logGroupNamePattern in your request, then only arn, creationTime, and logGroupName are
included in the response. logGroupNamePattern and logGroupNamePrefix are mutually
exclusive. Only one of these parameters can be passed.
- `"logGroupNamePrefix"`: The prefix to match. logGroupNamePrefix and logGroupNamePattern
are mutually exclusive. Only one of these parameters can be passed.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_log_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeLogGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_log_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeLogGroups", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_log_streams()
describe_log_streams(params::Dict{String,<:Any})
Lists the log streams for the specified log group. You can list all the log streams or
filter the results by prefix. You can also control how the results are ordered. You can
specify the log group to search by using either logGroupIdentifier or logGroupName. You
must include one of these two parameters, but you can't include both. This operation has a
limit of five transactions per second, after which transactions are throttled. If you are
using CloudWatch cross-account observability, you can use this operation in a monitoring
account and view data from the linked source accounts. For more information, see CloudWatch
cross-account observability.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"descending"`: If the value is true, results are returned in descending order. If the
value is to false, results are returned in ascending order. The default value is false.
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default is up to 50 items.
- `"logGroupIdentifier"`: Specify either the name or ARN of the log group to view. If the
log group is in a source account and you are using a monitoring account, you must use the
log group ARN. You must include either logGroupIdentifier or logGroupName, but not both.
- `"logGroupName"`: The name of the log group. You must include either logGroupIdentifier
or logGroupName, but not both.
- `"logStreamNamePrefix"`: The prefix to match. If orderBy is LastEventTime, you cannot
specify this parameter.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"orderBy"`: If the value is LogStreamName, the results are ordered by log stream name.
If the value is LastEventTime, the results are ordered by the event time. The default value
is LogStreamName. If you order the results by event time, you cannot specify the
logStreamNamePrefix parameter. lastEventTimestamp represents the time of the most recent
log event in the log stream in CloudWatch Logs. This number is expressed as the number of
milliseconds after Jan 1, 1970 00:00:00 UTC. lastEventTimestamp updates on an eventual
consistency basis. It typically updates in less than an hour from ingestion, but in rare
situations might take longer.
"""
function describe_log_streams(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeLogStreams"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_log_streams(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeLogStreams", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_metric_filters()
describe_metric_filters(params::Dict{String,<:Any})
Lists the specified metric filters. You can list all of the metric filters or filter the
results by log name, prefix, metric name, or metric namespace. The results are ASCII-sorted
by filter name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filterNamePrefix"`: The prefix to match. CloudWatch Logs uses the value that you set
here only if you also include the logGroupName parameter in your request.
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default is up to 50 items.
- `"logGroupName"`: The name of the log group.
- `"metricName"`: Filters results to include only those with the specified metric name. If
you include this parameter in your request, you must also include the metricNamespace
parameter.
- `"metricNamespace"`: Filters results to include only those in the specified namespace. If
you include this parameter in your request, you must also include the metricName parameter.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_metric_filters(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeMetricFilters"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_metric_filters(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeMetricFilters",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_queries()
describe_queries(params::Dict{String,<:Any})
Returns a list of CloudWatch Logs Insights queries that are scheduled, running, or have
been run recently in this account. You can request all queries or limit it to queries of a
specific log group or queries with a certain status.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"logGroupName"`: Limits the returned queries to only those for the specified log group.
- `"maxResults"`: Limits the number of returned queries to the specified number.
- `"nextToken"`:
- `"status"`: Limits the returned queries to only those that have the specified status.
Valid values are Cancelled, Complete, Failed, Running, and Scheduled.
"""
function describe_queries(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeQueries"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_queries(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeQueries", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
describe_query_definitions()
describe_query_definitions(params::Dict{String,<:Any})
This operation returns a paginated list of your saved CloudWatch Logs Insights query
definitions. You can retrieve query definitions from the current account or from a source
account that is linked to the current account. You can use the queryDefinitionNamePrefix
parameter to limit the results to only the query definitions that have names that start
with a certain string.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Limits the number of returned query definitions to the specified number.
- `"nextToken"`:
- `"queryDefinitionNamePrefix"`: Use this parameter to filter your results to only the
query definitions that have names that start with the prefix you specify.
"""
function describe_query_definitions(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeQueryDefinitions"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_query_definitions(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeQueryDefinitions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_resource_policies()
describe_resource_policies(params::Dict{String,<:Any})
Lists the resource policies in this account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of resource policies to be displayed with one call of this
API.
- `"nextToken"`:
"""
function describe_resource_policies(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DescribeResourcePolicies"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function describe_resource_policies(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeResourcePolicies",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_subscription_filters(log_group_name)
describe_subscription_filters(log_group_name, params::Dict{String,<:Any})
Lists the subscription filters for the specified log group. You can list all the
subscription filters or filter the results by prefix. The results are ASCII-sorted by
filter name.
# Arguments
- `log_group_name`: The name of the log group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filterNamePrefix"`: The prefix to match. If you don't specify a value, no prefix filter
is applied.
- `"limit"`: The maximum number of items returned. If you don't specify a value, the
default is up to 50 items.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
"""
function describe_subscription_filters(
logGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DescribeSubscriptionFilters",
Dict{String,Any}("logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_subscription_filters(
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"DescribeSubscriptionFilters",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logGroupName" => logGroupName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_kms_key()
disassociate_kms_key(params::Dict{String,<:Any})
Disassociates the specified KMS key from the specified log group or from all CloudWatch
Logs Insights query results in the account. When you use DisassociateKmsKey, you specify
either the logGroupName parameter or the resourceIdentifier parameter. You can't specify
both of those parameters in the same operation. Specify the logGroupName parameter to
stop using the KMS key to encrypt future log events ingested and stored in the log group.
Instead, they will be encrypted with the default CloudWatch Logs method. The log events
that were ingested while the key was associated with the log group are still encrypted with
that key. Therefore, CloudWatch Logs will need permissions for the key whenever that data
is accessed. Specify the resourceIdentifier parameter with the query-result resource to
stop using the KMS key to encrypt the results of all future StartQuery operations in the
account. They will instead be encrypted with the default CloudWatch Logs method. The
results from queries that ran while the key was associated with the account are still
encrypted with that key. Therefore, CloudWatch Logs will need permissions for the key
whenever that data is accessed. It can take up to 5 minutes for this operation to take
effect.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"logGroupName"`: The name of the log group. In your DisassociateKmsKey operation, you
must specify either the resourceIdentifier parameter or the logGroup parameter, but you
can't specify both.
- `"resourceIdentifier"`: Specifies the target for this operation. You must specify one of
the following: Specify the ARN of a log group to stop having CloudWatch Logs use the KMS
key to encrypt log events that are ingested and stored by that log group. After you run
this operation, CloudWatch Logs encrypts ingested log events with the default CloudWatch
Logs method. The log group ARN must be in the following format. Replace REGION and
ACCOUNT_ID with your Region and account ID.
arn:aws:logs:REGION:ACCOUNT_ID:log-group:LOG_GROUP_NAME Specify the following ARN to
stop using this key to encrypt the results of future StartQuery operations in this account.
Replace REGION and ACCOUNT_ID with your Region and account ID.
arn:aws:logs:REGION:ACCOUNT_ID:query-result:* In your DisssociateKmsKey operation, you
must specify either the resourceIdentifier parameter or the logGroup parameter, but you
can't specify both.
"""
function disassociate_kms_key(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"DisassociateKmsKey"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function disassociate_kms_key(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"DisassociateKmsKey", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
filter_log_events()
filter_log_events(params::Dict{String,<:Any})
Lists log events from the specified log group. You can list all the log events or filter
the results using a filter pattern, a time range, and the name of the log stream. You must
have the logs:FilterLogEvents permission to perform this operation. You can specify the log
group to search by using either logGroupIdentifier or logGroupName. You must include one of
these two parameters, but you can't include both. By default, this operation returns as
many log events as can fit in 1 MB (up to 10,000 log events) or all the events found within
the specified time range. If the results include a token, that means there are more log
events available. You can get additional results by specifying the token in a subsequent
call. This operation can return empty results while there are more log events available
through the token. The returned log events are sorted by event timestamp, the timestamp
when the event was ingested by CloudWatch Logs, and the ID of the PutLogEvents request. If
you are using CloudWatch cross-account observability, you can use this operation in a
monitoring account and view data from the linked source accounts. For more information, see
CloudWatch cross-account observability.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"endTime"`: The end of the time range, expressed as the number of milliseconds after Jan
1, 1970 00:00:00 UTC. Events with a timestamp later than this time are not returned.
- `"filterPattern"`: The filter pattern to use. For more information, see Filter and
Pattern Syntax. If not provided, all the events are matched.
- `"interleaved"`: If the value is true, the operation attempts to provide responses that
contain events from multiple log streams within the log group, interleaved in a single
response. If the value is false, all the matched log events in the first log stream are
searched first, then those in the next log stream, and so on. Important As of June 17,
2019, this parameter is ignored and the value is assumed to be true. The response from this
operation always interleaves events from multiple log streams within a log group.
- `"limit"`: The maximum number of events to return. The default is 10,000 events.
- `"logGroupIdentifier"`: Specify either the name or ARN of the log group to view log
events from. If the log group is in a source account and you are using a monitoring
account, you must use the log group ARN. You must include either logGroupIdentifier or
logGroupName, but not both.
- `"logGroupName"`: The name of the log group to search. You must include either
logGroupIdentifier or logGroupName, but not both.
- `"logStreamNamePrefix"`: Filters the results to include only events from log streams that
have names starting with this prefix. If you specify a value for both logStreamNamePrefix
and logStreamNames, but the value for logStreamNamePrefix does not match any log stream
names specified in logStreamNames, the action returns an InvalidParameterException error.
- `"logStreamNames"`: Filters the results to only logs from the log streams in this list.
If you specify a value for both logStreamNamePrefix and logStreamNames, the action returns
an InvalidParameterException error.
- `"nextToken"`: The token for the next set of events to return. (You received this token
from a previous call.)
- `"startTime"`: The start of the time range, expressed as the number of milliseconds after
Jan 1, 1970 00:00:00 UTC. Events with a timestamp before this time are not returned.
- `"unmask"`: Specify true to display the log event fields with all sensitive data unmasked
and visible. The default is false. To use this operation with this parameter, you must be
signed into an account with the logs:Unmask permission.
"""
function filter_log_events(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"FilterLogEvents"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function filter_log_events(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"FilterLogEvents", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_data_protection_policy(log_group_identifier)
get_data_protection_policy(log_group_identifier, params::Dict{String,<:Any})
Returns information about a log group data protection policy.
# Arguments
- `log_group_identifier`: The name or ARN of the log group that contains the data
protection policy that you want to see.
"""
function get_data_protection_policy(
logGroupIdentifier; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetDataProtectionPolicy",
Dict{String,Any}("logGroupIdentifier" => logGroupIdentifier);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_data_protection_policy(
logGroupIdentifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"GetDataProtectionPolicy",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("logGroupIdentifier" => logGroupIdentifier), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_delivery(id)
get_delivery(id, params::Dict{String,<:Any})
Returns complete information about one logical delivery. A delivery is a connection between
a delivery source and a delivery destination . A delivery source represents an Amazon
Web Services resource that sends logs to an logs delivery destination. The destination can
be CloudWatch Logs, Amazon S3, or Firehose. Only some Amazon Web Services services support
being configured as a delivery source. These services are listed in Enable logging from
Amazon Web Services services. You need to specify the delivery id in this operation. You
can find the IDs of the deliveries in your account with the DescribeDeliveries operation.
# Arguments
- `id`: The ID of the delivery that you want to retrieve.
"""
function get_delivery(id; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetDelivery",
Dict{String,Any}("id" => id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_delivery(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetDelivery",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("id" => id), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_delivery_destination(name)
get_delivery_destination(name, params::Dict{String,<:Any})
Retrieves complete information about one delivery destination.
# Arguments
- `name`: The name of the delivery destination that you want to retrieve.
"""
function get_delivery_destination(name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetDeliveryDestination",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_delivery_destination(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetDeliveryDestination",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_delivery_destination_policy(delivery_destination_name)
get_delivery_destination_policy(delivery_destination_name, params::Dict{String,<:Any})
Retrieves the delivery destination policy assigned to the delivery destination that you
specify. For more information about delivery destinations and their policies, see
PutDeliveryDestinationPolicy.
# Arguments
- `delivery_destination_name`: The name of the delivery destination that you want to
retrieve the policy of.
"""
function get_delivery_destination_policy(
deliveryDestinationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetDeliveryDestinationPolicy",
Dict{String,Any}("deliveryDestinationName" => deliveryDestinationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_delivery_destination_policy(
deliveryDestinationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"GetDeliveryDestinationPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deliveryDestinationName" => deliveryDestinationName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_delivery_source(name)
get_delivery_source(name, params::Dict{String,<:Any})
Retrieves complete information about one delivery source.
# Arguments
- `name`: The name of the delivery source that you want to retrieve.
"""
function get_delivery_source(name; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetDeliverySource",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_delivery_source(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetDeliverySource",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_log_anomaly_detector(anomaly_detector_arn)
get_log_anomaly_detector(anomaly_detector_arn, params::Dict{String,<:Any})
Retrieves information about the log anomaly detector that you specify.
# Arguments
- `anomaly_detector_arn`: The ARN of the anomaly detector to retrieve information about.
You can find the ARNs of log anomaly detectors in your account by using the
ListLogAnomalyDetectors operation.
"""
function get_log_anomaly_detector(
anomalyDetectorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetLogAnomalyDetector",
Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_log_anomaly_detector(
anomalyDetectorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"GetLogAnomalyDetector",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_log_events(log_stream_name)
get_log_events(log_stream_name, params::Dict{String,<:Any})
Lists log events from the specified log stream. You can list all of the log events or
filter using a time range. By default, this operation returns as many log events as can fit
in a response size of 1MB (up to 10,000 log events). You can get additional log events by
specifying one of the tokens in a subsequent call. This operation can return empty results
while there are more log events available through the token. If you are using CloudWatch
cross-account observability, you can use this operation in a monitoring account and view
data from the linked source accounts. For more information, see CloudWatch cross-account
observability. You can specify the log group to search by using either logGroupIdentifier
or logGroupName. You must include one of these two parameters, but you can't include both.
# Arguments
- `log_stream_name`: The name of the log stream.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"endTime"`: The end of the time range, expressed as the number of milliseconds after Jan
1, 1970 00:00:00 UTC. Events with a timestamp equal to or later than this time are not
included.
- `"limit"`: The maximum number of log events returned. If you don't specify a limit, the
default is as many log events as can fit in a response size of 1 MB (up to 10,000 log
events).
- `"logGroupIdentifier"`: Specify either the name or ARN of the log group to view events
from. If the log group is in a source account and you are using a monitoring account, you
must use the log group ARN. You must include either logGroupIdentifier or logGroupName,
but not both.
- `"logGroupName"`: The name of the log group. You must include either logGroupIdentifier
or logGroupName, but not both.
- `"nextToken"`: The token for the next set of items to return. (You received this token
from a previous call.)
- `"startFromHead"`: If the value is true, the earliest log events are returned first. If
the value is false, the latest log events are returned first. The default value is false.
If you are using a previous nextForwardToken value as the nextToken in this operation, you
must specify true for startFromHead.
- `"startTime"`: The start of the time range, expressed as the number of milliseconds after
Jan 1, 1970 00:00:00 UTC. Events with a timestamp equal to this time or later than this
time are included. Events with a timestamp earlier than this time are not included.
- `"unmask"`: Specify true to display the log event fields with all sensitive data unmasked
and visible. The default is false. To use this operation with this parameter, you must be
signed into an account with the logs:Unmask permission.
"""
function get_log_events(logStreamName; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetLogEvents",
Dict{String,Any}("logStreamName" => logStreamName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_log_events(
logStreamName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"GetLogEvents",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logStreamName" => logStreamName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_log_group_fields()
get_log_group_fields(params::Dict{String,<:Any})
Returns a list of the fields that are included in log events in the specified log group.
Includes the percentage of log events that contain each field. The search is limited to a
time period that you specify. You can specify the log group to search by using either
logGroupIdentifier or logGroupName. You must specify one of these parameters, but you can't
specify both. In the results, fields that start with @ are fields generated by CloudWatch
Logs. For example, @timestamp is the timestamp of each log event. For more information
about the fields that are generated by CloudWatch logs, see Supported Logs and Discovered
Fields. The response results are sorted by the frequency percentage, starting with the
highest percentage. If you are using CloudWatch cross-account observability, you can use
this operation in a monitoring account and view data from the linked source accounts. For
more information, see CloudWatch cross-account observability.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"logGroupIdentifier"`: Specify either the name or ARN of the log group to view. If the
log group is in a source account and you are using a monitoring account, you must specify
the ARN. You must include either logGroupIdentifier or logGroupName, but not both.
- `"logGroupName"`: The name of the log group to search. You must include either
logGroupIdentifier or logGroupName, but not both.
- `"time"`: The time to set as the center of the query. If you specify time, the 8 minutes
before and 8 minutes after this time are searched. If you omit time, the most recent 15
minutes up to the current time are searched. The time value is specified as epoch time,
which is the number of seconds since January 1, 1970, 00:00:00 UTC.
"""
function get_log_group_fields(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetLogGroupFields"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_log_group_fields(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetLogGroupFields", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_log_record(log_record_pointer)
get_log_record(log_record_pointer, params::Dict{String,<:Any})
Retrieves all of the fields and values of a single log event. All fields are retrieved,
even if the original query that produced the logRecordPointer retrieved only a subset of
fields. Fields are returned as field name/field value pairs. The full unparsed log event is
returned within @message.
# Arguments
- `log_record_pointer`: The pointer corresponding to the log event record you want to
retrieve. You get this from the response of a GetQueryResults operation. In that response,
the value of the @ptr field for a log event is the value to use as logRecordPointer to
retrieve that complete log event record.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"unmask"`: Specify true to display the log event fields with all sensitive data unmasked
and visible. The default is false. To use this operation with this parameter, you must be
signed into an account with the logs:Unmask permission.
"""
function get_log_record(logRecordPointer; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetLogRecord",
Dict{String,Any}("logRecordPointer" => logRecordPointer);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_log_record(
logRecordPointer,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"GetLogRecord",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("logRecordPointer" => logRecordPointer), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_query_results(query_id)
get_query_results(query_id, params::Dict{String,<:Any})
Returns the results from the specified query. Only the fields requested in the query are
returned, along with a @ptr field, which is the identifier for the log record. You can use
the value of @ptr in a GetLogRecord operation to get the full log record. GetQueryResults
does not start running a query. To run a query, use StartQuery. For more information about
how long results of previous queries are available, see CloudWatch Logs quotas. If the
value of the Status field in the output is Running, this operation returns only partial
results. If you see a value of Scheduled or Running for the status, you can retry the
operation later to see the final results. If you are using CloudWatch cross-account
observability, you can use this operation in a monitoring account to start queries in
linked source accounts. For more information, see CloudWatch cross-account observability.
# Arguments
- `query_id`: The ID number of the query.
"""
function get_query_results(queryId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"GetQueryResults",
Dict{String,Any}("queryId" => queryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_query_results(
queryId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"GetQueryResults",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("queryId" => queryId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_anomalies()
list_anomalies(params::Dict{String,<:Any})
Returns a list of anomalies that log anomaly detectors have found. For details about the
structure format of each anomaly object that is returned, see the example in this section.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"anomalyDetectorArn"`: Use this to optionally limit the results to only the anomalies
found by a certain anomaly detector.
- `"limit"`: The maximum number of items to return. If you don't specify a value, the
default maximum value of 50 items is used.
- `"nextToken"`:
- `"suppressionState"`: You can specify this parameter if you want to the operation to
return only anomalies that are currently either suppressed or unsuppressed.
"""
function list_anomalies(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"ListAnomalies"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_anomalies(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"ListAnomalies", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_log_anomaly_detectors()
list_log_anomaly_detectors(params::Dict{String,<:Any})
Retrieves a list of the log anomaly detectors in the account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filterLogGroupArn"`: Use this to optionally filter the results to only include anomaly
detectors that are associated with the specified log group.
- `"limit"`: The maximum number of items to return. If you don't specify a value, the
default maximum value of 50 items is used.
- `"nextToken"`:
"""
function list_log_anomaly_detectors(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"ListLogAnomalyDetectors"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_log_anomaly_detectors(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"ListLogAnomalyDetectors",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Displays the tags associated with a CloudWatch Logs resource. Currently, log groups and
destinations support tagging.
# Arguments
- `resource_arn`: The ARN of the resource that you want to view tags for. The ARN format of
a log group is arn:aws:logs:Region:account-id:log-group:log-group-name The ARN format of
a destination is arn:aws:logs:Region:account-id:destination:destination-name For more
information about ARN format, see CloudWatch Logs resources and operations.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"ListTagsForResource",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_log_group(log_group_name)
list_tags_log_group(log_group_name, params::Dict{String,<:Any})
The ListTagsLogGroup operation is on the path to deprecation. We recommend that you use
ListTagsForResource instead. Lists the tags for the specified log group.
# Arguments
- `log_group_name`: The name of the log group.
"""
function list_tags_log_group(
logGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"ListTagsLogGroup",
Dict{String,Any}("logGroupName" => logGroupName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_log_group(
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"ListTagsLogGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("logGroupName" => logGroupName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_account_policy(policy_document, policy_name, policy_type)
put_account_policy(policy_document, policy_name, policy_type, params::Dict{String,<:Any})
Creates an account-level data protection policy or subscription filter policy that applies
to all log groups or a subset of log groups in the account. Data protection policy A data
protection policy can help safeguard sensitive data that's ingested by your log groups by
auditing and masking the sensitive log data. Each account can have only one account-level
data protection policy. Sensitive data is detected and masked when it is ingested into a
log group. When you set a data protection policy, log events ingested into the log groups
before that time are not masked. If you use PutAccountPolicy to create a data protection
policy for your whole account, it applies to both existing log groups and all log groups
that are created later in this account. The account-level policy is applied to existing log
groups with eventual consistency. It might take up to 5 minutes before sensitive data in
existing log groups begins to be masked. By default, when a user views a log event that
includes masked data, the sensitive data is replaced by asterisks. A user who has the
logs:Unmask permission can use a GetLogEvents or FilterLogEvents operation with the unmask
parameter set to true to view the unmasked log events. Users with the logs:Unmask can also
view unmasked data in the CloudWatch Logs console by running a CloudWatch Logs Insights
query with the unmask query command. For more information, including a list of types of
data that can be audited and masked, see Protect sensitive log data with masking. To use
the PutAccountPolicy operation for a data protection policy, you must be signed on with the
logs:PutDataProtectionPolicy and logs:PutAccountPolicy permissions. The PutAccountPolicy
operation applies to all log groups in the account. You can use PutDataProtectionPolicy to
create a data protection policy that applies to just one log group. If a log group has its
own data protection policy and the account also has an account-level data protection
policy, then the two policies are cumulative. Any sensitive term specified in either policy
is masked. Subscription filter policy A subscription filter policy sets up a real-time
feed of log events from CloudWatch Logs to other Amazon Web Services services.
Account-level subscription filter policies apply to both existing log groups and log groups
that are created later in this account. Supported destinations are Kinesis Data Streams,
Firehose, and Lambda. When log events are sent to the receiving service, they are Base64
encoded and compressed with the GZIP format. The following destinations are supported for
subscription filters: An Kinesis Data Streams data stream in the same account as the
subscription policy, for same-account delivery. An Firehose data stream in the same
account as the subscription policy, for same-account delivery. A Lambda function in the
same account as the subscription policy, for same-account delivery. A logical destination
in a different account created with PutDestination, for cross-account delivery. Kinesis
Data Streams and Firehose are supported as logical destinations. Each account can have
one account-level subscription filter policy. If you are updating an existing filter, you
must specify the correct name in PolicyName. To perform a PutAccountPolicy subscription
filter operation for any destination except a Lambda function, you must also have the
iam:PassRole permission.
# Arguments
- `policy_document`: Specify the policy, in JSON. Data protection policy A data
protection policy must include two JSON blocks: The first block must include both a
DataIdentifer array and an Operation property with an Audit action. The DataIdentifer array
lists the types of sensitive data that you want to mask. For more information about the
available options, see Types of data that you can mask. The Operation property with an
Audit action is required to find the sensitive data terms. This Audit action must contain a
FindingsDestination object. You can optionally use that FindingsDestination object to list
one or more destinations to send audit findings to. If you specify destinations such as log
groups, Firehose streams, and S3 buckets, they must already exist. The second block must
include both a DataIdentifer array and an Operation property with an Deidentify action. The
DataIdentifer array must exactly match the DataIdentifer array in the first block of the
policy. The Operation property with the Deidentify action is what actually masks the data,
and it must contain the \"MaskConfig\": {} object. The \"MaskConfig\": {} object must be
empty. For an example data protection policy, see the Examples section on this page. The
contents of the two DataIdentifer arrays must match exactly. In addition to the two JSON
blocks, the policyDocument can also include Name, Description, and Version fields. The Name
is different than the operation's policyName parameter, and is used as a dimension when
CloudWatch Logs reports audit findings metrics to CloudWatch. The JSON specified in
policyDocument can be up to 30,720 characters long. Subscription filter policy A
subscription filter policy can include the following attributes in a JSON block:
DestinationArn The ARN of the destination to deliver log events to. Supported destinations
are: An Kinesis Data Streams data stream in the same account as the subscription policy,
for same-account delivery. An Firehose data stream in the same account as the
subscription policy, for same-account delivery. A Lambda function in the same account as
the subscription policy, for same-account delivery. A logical destination in a different
account created with PutDestination, for cross-account delivery. Kinesis Data Streams and
Firehose are supported as logical destinations. RoleArn The ARN of an IAM role that
grants CloudWatch Logs permissions to deliver ingested log events to the destination
stream. You don't need to provide the ARN when you are working with a logical destination
for cross-account delivery. FilterPattern A filter pattern for subscribing to a filtered
stream of log events. DistributionThe method used to distribute log data to the
destination. By default, log data is grouped by log stream, but the grouping can be set to
Random for a more even distribution. This property is only applicable when the destination
is an Kinesis Data Streams data stream.
- `policy_name`: A name for the policy. This must be unique within the account.
- `policy_type`: The type of policy that you're creating or updating.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"scope"`: Currently the only valid value for this parameter is ALL, which specifies that
the data protection policy applies to all log groups in the account. If you omit this
parameter, the default of ALL is used.
- `"selectionCriteria"`: Use this parameter to apply the subscription filter policy to a
subset of log groups in the account. Currently, the only supported filter is LogGroupName
NOT IN []. The selectionCriteria string can be up to 25KB in length. The length is
determined by using its UTF-8 bytes. Using the selectionCriteria parameter is useful to
help prevent infinite loops. For more information, see Log recursion prevention. Specifing
selectionCriteria is valid only when you specify SUBSCRIPTION_FILTER_POLICY for policyType.
"""
function put_account_policy(
policyDocument,
policyName,
policyType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutAccountPolicy",
Dict{String,Any}(
"policyDocument" => policyDocument,
"policyName" => policyName,
"policyType" => policyType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_account_policy(
policyDocument,
policyName,
policyType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutAccountPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"policyDocument" => policyDocument,
"policyName" => policyName,
"policyType" => policyType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_data_protection_policy(log_group_identifier, policy_document)
put_data_protection_policy(log_group_identifier, policy_document, params::Dict{String,<:Any})
Creates a data protection policy for the specified log group. A data protection policy can
help safeguard sensitive data that's ingested by the log group by auditing and masking the
sensitive log data. Sensitive data is detected and masked when it is ingested into the log
group. When you set a data protection policy, log events ingested into the log group before
that time are not masked. By default, when a user views a log event that includes masked
data, the sensitive data is replaced by asterisks. A user who has the logs:Unmask
permission can use a GetLogEvents or FilterLogEvents operation with the unmask parameter
set to true to view the unmasked log events. Users with the logs:Unmask can also view
unmasked data in the CloudWatch Logs console by running a CloudWatch Logs Insights query
with the unmask query command. For more information, including a list of types of data that
can be audited and masked, see Protect sensitive log data with masking. The
PutDataProtectionPolicy operation applies to only the specified log group. You can also use
PutAccountPolicy to create an account-level data protection policy that applies to all log
groups in the account, including both existing log groups and log groups that are created
level. If a log group has its own data protection policy and the account also has an
account-level data protection policy, then the two policies are cumulative. Any sensitive
term specified in either policy is masked.
# Arguments
- `log_group_identifier`: Specify either the log group name or log group ARN.
- `policy_document`: Specify the data protection policy, in JSON. This policy must include
two JSON blocks: The first block must include both a DataIdentifer array and an Operation
property with an Audit action. The DataIdentifer array lists the types of sensitive data
that you want to mask. For more information about the available options, see Types of data
that you can mask. The Operation property with an Audit action is required to find the
sensitive data terms. This Audit action must contain a FindingsDestination object. You can
optionally use that FindingsDestination object to list one or more destinations to send
audit findings to. If you specify destinations such as log groups, Firehose streams, and S3
buckets, they must already exist. The second block must include both a DataIdentifer
array and an Operation property with an Deidentify action. The DataIdentifer array must
exactly match the DataIdentifer array in the first block of the policy. The Operation
property with the Deidentify action is what actually masks the data, and it must contain
the \"MaskConfig\": {} object. The \"MaskConfig\": {} object must be empty. For an
example data protection policy, see the Examples section on this page. The contents of the
two DataIdentifer arrays must match exactly. In addition to the two JSON blocks, the
policyDocument can also include Name, Description, and Version fields. The Name is used as
a dimension when CloudWatch Logs reports audit findings metrics to CloudWatch. The JSON
specified in policyDocument can be up to 30,720 characters.
"""
function put_data_protection_policy(
logGroupIdentifier, policyDocument; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutDataProtectionPolicy",
Dict{String,Any}(
"logGroupIdentifier" => logGroupIdentifier, "policyDocument" => policyDocument
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_data_protection_policy(
logGroupIdentifier,
policyDocument,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDataProtectionPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupIdentifier" => logGroupIdentifier,
"policyDocument" => policyDocument,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_delivery_destination(delivery_destination_configuration, name)
put_delivery_destination(delivery_destination_configuration, name, params::Dict{String,<:Any})
Creates or updates a logical delivery destination. A delivery destination is an Amazon Web
Services resource that represents an Amazon Web Services service that logs can be sent to.
CloudWatch Logs, Amazon S3, and Firehose are supported as logs delivery destinations. To
configure logs delivery between a supported Amazon Web Services service and a destination,
you must do the following: Create a delivery source, which is a logical object that
represents the resource that is actually sending the logs. For more information, see
PutDeliverySource. Use PutDeliveryDestination to create a delivery destination, which is
a logical object that represents the actual delivery destination. If you are delivering
logs cross-account, you must use PutDeliveryDestinationPolicy in the destination account to
assign an IAM policy to the destination. This policy allows delivery to that destination.
Use CreateDelivery to create a delivery by pairing exactly one delivery source and one
delivery destination. For more information, see CreateDelivery. You can configure a
single delivery source to send logs to multiple destinations by creating multiple
deliveries. You can also create multiple deliveries to configure multiple delivery sources
to send logs to the same delivery destination. Only some Amazon Web Services services
support being configured as a delivery source. These services are listed as Supported [V2
Permissions] in the table at Enabling logging from Amazon Web Services services. If you
use this operation to update an existing delivery destination, all the current delivery
destination parameters are overwritten with the new parameter values that you specify.
# Arguments
- `delivery_destination_configuration`: A structure that contains the ARN of the Amazon Web
Services resource that will receive the logs.
- `name`: A name for this delivery destination. This name must be unique for all delivery
destinations in your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"outputFormat"`: The format for the logs that this delivery destination will receive.
- `"tags"`: An optional list of key-value pairs to associate with the resource. For more
information about tagging, see Tagging Amazon Web Services resources
"""
function put_delivery_destination(
deliveryDestinationConfiguration,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDeliveryDestination",
Dict{String,Any}(
"deliveryDestinationConfiguration" => deliveryDestinationConfiguration,
"name" => name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_delivery_destination(
deliveryDestinationConfiguration,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDeliveryDestination",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"deliveryDestinationConfiguration" => deliveryDestinationConfiguration,
"name" => name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_delivery_destination_policy(delivery_destination_name, delivery_destination_policy)
put_delivery_destination_policy(delivery_destination_name, delivery_destination_policy, params::Dict{String,<:Any})
Creates and assigns an IAM policy that grants permissions to CloudWatch Logs to deliver
logs cross-account to a specified destination in this account. To configure the delivery of
logs from an Amazon Web Services service in another account to a logs delivery destination
in the current account, you must do the following: Create a delivery source, which is a
logical object that represents the resource that is actually sending the logs. For more
information, see PutDeliverySource. Create a delivery destination, which is a logical
object that represents the actual delivery destination. For more information, see
PutDeliveryDestination. Use this operation in the destination account to assign an IAM
policy to the destination. This policy allows delivery to that destination. Create a
delivery by pairing exactly one delivery source and one delivery destination. For more
information, see CreateDelivery. Only some Amazon Web Services services support being
configured as a delivery source. These services are listed as Supported [V2 Permissions] in
the table at Enabling logging from Amazon Web Services services. The contents of the
policy must include two statements. One statement enables general logs delivery, and the
other allows delivery to the chosen destination. See the examples for the needed policies.
# Arguments
- `delivery_destination_name`: The name of the delivery destination to assign this policy
to.
- `delivery_destination_policy`: The contents of the policy.
"""
function put_delivery_destination_policy(
deliveryDestinationName,
deliveryDestinationPolicy;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDeliveryDestinationPolicy",
Dict{String,Any}(
"deliveryDestinationName" => deliveryDestinationName,
"deliveryDestinationPolicy" => deliveryDestinationPolicy,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_delivery_destination_policy(
deliveryDestinationName,
deliveryDestinationPolicy,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDeliveryDestinationPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"deliveryDestinationName" => deliveryDestinationName,
"deliveryDestinationPolicy" => deliveryDestinationPolicy,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_delivery_source(log_type, name, resource_arn)
put_delivery_source(log_type, name, resource_arn, params::Dict{String,<:Any})
Creates or updates a logical delivery source. A delivery source represents an Amazon Web
Services resource that sends logs to an logs delivery destination. The destination can be
CloudWatch Logs, Amazon S3, or Firehose. To configure logs delivery between a delivery
destination and an Amazon Web Services service that is supported as a delivery source, you
must do the following: Use PutDeliverySource to create a delivery source, which is a
logical object that represents the resource that is actually sending the logs. Use
PutDeliveryDestination to create a delivery destination, which is a logical object that
represents the actual delivery destination. For more information, see
PutDeliveryDestination. If you are delivering logs cross-account, you must use
PutDeliveryDestinationPolicy in the destination account to assign an IAM policy to the
destination. This policy allows delivery to that destination. Use CreateDelivery to
create a delivery by pairing exactly one delivery source and one delivery destination. For
more information, see CreateDelivery. You can configure a single delivery source to send
logs to multiple destinations by creating multiple deliveries. You can also create multiple
deliveries to configure multiple delivery sources to send logs to the same delivery
destination. Only some Amazon Web Services services support being configured as a delivery
source. These services are listed as Supported [V2 Permissions] in the table at Enabling
logging from Amazon Web Services services. If you use this operation to update an existing
delivery source, all the current delivery source parameters are overwritten with the new
parameter values that you specify.
# Arguments
- `log_type`: Defines the type of log that the source is sending. For Amazon
CodeWhisperer, the valid value is EVENT_LOGS. For IAM Identity Centerr, the valid value
is ERROR_LOGS. For Amazon WorkMail, the valid values are ACCESS_CONTROL_LOGS,
AUTHENTICATION_LOGS, WORKMAIL_AVAILABILITY_PROVIDER_LOGS, and WORKMAIL_MAILBOX_ACCESS_LOGS.
- `name`: A name for this delivery source. This name must be unique for all delivery
sources in your account.
- `resource_arn`: The ARN of the Amazon Web Services resource that is generating and
sending logs. For example,
arn:aws:workmail:us-east-1:123456789012:organization/m-1234EXAMPLEabcd1234abcd1234abcd1234
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: An optional list of key-value pairs to associate with the resource. For more
information about tagging, see Tagging Amazon Web Services resources
"""
function put_delivery_source(
logType, name, resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutDeliverySource",
Dict{String,Any}(
"logType" => logType, "name" => name, "resourceArn" => resourceArn
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_delivery_source(
logType,
name,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDeliverySource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logType" => logType, "name" => name, "resourceArn" => resourceArn
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_destination(destination_name, role_arn, target_arn)
put_destination(destination_name, role_arn, target_arn, params::Dict{String,<:Any})
Creates or updates a destination. This operation is used only to create destinations for
cross-account subscriptions. A destination encapsulates a physical resource (such as an
Amazon Kinesis stream). With a destination, you can subscribe to a real-time stream of log
events for a different account, ingested using PutLogEvents. Through an access policy, a
destination controls what is written to it. By default, PutDestination does not set any
access policy with the destination, which means a cross-account user cannot call
PutSubscriptionFilter against this destination. To enable this, the destination owner must
call PutDestinationPolicy after PutDestination. To perform a PutDestination operation, you
must also have the iam:PassRole permission.
# Arguments
- `destination_name`: A name for the destination.
- `role_arn`: The ARN of an IAM role that grants CloudWatch Logs permissions to call the
Amazon Kinesis PutRecord operation on the destination stream.
- `target_arn`: The ARN of an Amazon Kinesis stream to which to deliver matching log events.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: An optional list of key-value pairs to associate with the resource. For more
information about tagging, see Tagging Amazon Web Services resources
"""
function put_destination(
destinationName, roleArn, targetArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutDestination",
Dict{String,Any}(
"destinationName" => destinationName,
"roleArn" => roleArn,
"targetArn" => targetArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_destination(
destinationName,
roleArn,
targetArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDestination",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationName" => destinationName,
"roleArn" => roleArn,
"targetArn" => targetArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_destination_policy(access_policy, destination_name)
put_destination_policy(access_policy, destination_name, params::Dict{String,<:Any})
Creates or updates an access policy associated with an existing destination. An access
policy is an IAM policy document that is used to authorize claims to register a
subscription filter against a given destination.
# Arguments
- `access_policy`: An IAM policy document that authorizes cross-account users to deliver
their log events to the associated destination. This can be up to 5120 bytes.
- `destination_name`: A name for an existing destination.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"forceUpdate"`: Specify true if you are updating an existing destination policy to grant
permission to an organization ID instead of granting permission to individual Amazon Web
Services accounts. Before you update a destination policy this way, you must first update
the subscription filters in the accounts that send logs to this destination. If you do not,
the subscription filters might stop working. By specifying true for forceUpdate, you are
affirming that you have already updated the subscription filters. For more information, see
Updating an existing cross-account subscription If you omit this parameter, the default
of false is used.
"""
function put_destination_policy(
accessPolicy, destinationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutDestinationPolicy",
Dict{String,Any}(
"accessPolicy" => accessPolicy, "destinationName" => destinationName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_destination_policy(
accessPolicy,
destinationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutDestinationPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"accessPolicy" => accessPolicy, "destinationName" => destinationName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_log_events(log_events, log_group_name, log_stream_name)
put_log_events(log_events, log_group_name, log_stream_name, params::Dict{String,<:Any})
Uploads a batch of log events to the specified log stream. The sequence token is now
ignored in PutLogEvents actions. PutLogEvents actions are always accepted and never return
InvalidSequenceTokenException or DataAlreadyAcceptedException even if the sequence token is
not valid. You can use parallel PutLogEvents actions on the same log stream. The batch of
events must satisfy the following constraints: The maximum batch size is 1,048,576 bytes.
This size is calculated as the sum of all event messages in UTF-8, plus 26 bytes for each
log event. None of the log events in the batch can be more than 2 hours in the future.
None of the log events in the batch can be more than 14 days in the past. Also, none of the
log events can be from earlier than the retention period of the log group. The log events
in the batch must be in chronological order by their timestamp. The timestamp is the time
that the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00
UTC. (In Amazon Web Services Tools for PowerShell and the Amazon Web Services SDK for .NET,
the timestamp is specified in .NET format: yyyy-mm-ddThh:mm:ss. For example,
2017-09-15T13:45:30.) A batch of log events in a single request cannot span more than 24
hours. Otherwise, the operation fails. Each log event can be no larger than 256 KB. The
maximum number of log events in a batch is 10,000. The quota of five requests per second
per log stream has been removed. Instead, PutLogEvents actions are throttled based on a
per-second per-account quota. You can request an increase to the per-second throttling
quota by using the Service Quotas service. If a call to PutLogEvents returns
\"UnrecognizedClientException\" the most likely cause is a non-valid Amazon Web Services
access key ID or secret key.
# Arguments
- `log_events`: The log events.
- `log_group_name`: The name of the log group.
- `log_stream_name`: The name of the log stream.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sequenceToken"`: The sequence token obtained from the response of the previous
PutLogEvents call. The sequenceToken parameter is now ignored in PutLogEvents actions.
PutLogEvents actions are now accepted and never return InvalidSequenceTokenException or
DataAlreadyAcceptedException even if the sequence token is not valid.
"""
function put_log_events(
logEvents,
logGroupName,
logStreamName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutLogEvents",
Dict{String,Any}(
"logEvents" => logEvents,
"logGroupName" => logGroupName,
"logStreamName" => logStreamName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_log_events(
logEvents,
logGroupName,
logStreamName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutLogEvents",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logEvents" => logEvents,
"logGroupName" => logGroupName,
"logStreamName" => logStreamName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_metric_filter(filter_name, filter_pattern, log_group_name, metric_transformations)
put_metric_filter(filter_name, filter_pattern, log_group_name, metric_transformations, params::Dict{String,<:Any})
Creates or updates a metric filter and associates it with the specified log group. With
metric filters, you can configure rules to extract metric data from log events ingested
through PutLogEvents. The maximum number of metric filters that can be associated with a
log group is 100. When you create a metric filter, you can also optionally assign a unit
and dimensions to the metric that is created. Metrics extracted from log events are
charged as custom metrics. To prevent unexpected high charges, do not specify
high-cardinality fields such as IPAddress or requestID as dimensions. Each different value
found for a dimension is treated as a separate metric and accrues charges as a separate
custom metric. CloudWatch Logs might disable a metric filter if it generates 1,000
different name/value pairs for your specified dimensions within one hour. You can also set
up a billing alarm to alert you if your charges are higher than expected. For more
information, see Creating a Billing Alarm to Monitor Your Estimated Amazon Web Services
Charges.
# Arguments
- `filter_name`: A name for the metric filter.
- `filter_pattern`: A filter pattern for extracting metric data out of ingested log events.
- `log_group_name`: The name of the log group.
- `metric_transformations`: A collection of information that defines how metric data gets
emitted.
"""
function put_metric_filter(
filterName,
filterPattern,
logGroupName,
metricTransformations;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutMetricFilter",
Dict{String,Any}(
"filterName" => filterName,
"filterPattern" => filterPattern,
"logGroupName" => logGroupName,
"metricTransformations" => metricTransformations,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_metric_filter(
filterName,
filterPattern,
logGroupName,
metricTransformations,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutMetricFilter",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filterName" => filterName,
"filterPattern" => filterPattern,
"logGroupName" => logGroupName,
"metricTransformations" => metricTransformations,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_query_definition(name, query_string)
put_query_definition(name, query_string, params::Dict{String,<:Any})
Creates or updates a query definition for CloudWatch Logs Insights. For more information,
see Analyzing Log Data with CloudWatch Logs Insights. To update a query definition, specify
its queryDefinitionId in your request. The values of name, queryString, and logGroupNames
are changed to the values that you specify in your update operation. No current values are
retained from the current query definition. For example, imagine updating a current query
definition that includes log groups. If you don't specify the logGroupNames parameter in
your update operation, the query definition changes to contain no log groups. You must have
the logs:PutQueryDefinition permission to be able to perform this operation.
# Arguments
- `name`: A name for the query definition. If you are saving numerous query definitions, we
recommend that you name them. This way, you can find the ones you want by using the first
part of the name as a filter in the queryDefinitionNamePrefix parameter of
DescribeQueryDefinitions.
- `query_string`: The query string to use for this definition. For more information, see
CloudWatch Logs Insights Query Syntax.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: Used as an idempotency token, to avoid returning an exception if the
service receives the same request twice because of a network error.
- `"logGroupNames"`: Use this parameter to include specific log groups as part of your
query definition. If you are updating a query definition and you omit this parameter, then
the updated definition will contain no log groups.
- `"queryDefinitionId"`: If you are updating a query definition, use this parameter to
specify the ID of the query definition that you want to update. You can use
DescribeQueryDefinitions to retrieve the IDs of your saved query definitions. If you are
creating a query definition, do not specify this parameter. CloudWatch generates a unique
ID for the new query definition and include it in the response to this operation.
"""
function put_query_definition(
name, queryString; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutQueryDefinition",
Dict{String,Any}(
"name" => name, "queryString" => queryString, "clientToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_query_definition(
name,
queryString,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutQueryDefinition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"name" => name,
"queryString" => queryString,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_resource_policy()
put_resource_policy(params::Dict{String,<:Any})
Creates or updates a resource policy allowing other Amazon Web Services services to put log
events to this account, such as Amazon Route 53. An account can have up to 10 resource
policies per Amazon Web Services Region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"policyDocument"`: Details of the new policy, including the identity of the principal
that is enabled to put logs to this account. This is formatted as a JSON string. This
parameter is required. The following example creates a resource policy enabling the Route
53 service to put DNS query logs in to the specified log group. Replace \"logArn\" with the
ARN of your CloudWatch Logs resource, such as a log group or log stream. CloudWatch Logs
also supports aws:SourceArn and aws:SourceAccount condition context keys. In the example
resource policy, you would replace the value of SourceArn with the resource making the call
from Route 53 to CloudWatch Logs. You would also replace the value of SourceAccount with
the Amazon Web Services account ID making that call. { \"Version\": \"2012-10-17\",
\"Statement\": [ { \"Sid\": \"Route53LogsToCloudWatchLogs\", \"Effect\": \"Allow\",
\"Principal\": { \"Service\": [ \"route53.amazonaws.com\" ] }, \"Action\":
\"logs:PutLogEvents\", \"Resource\": \"logArn\", \"Condition\": { \"ArnLike\": {
\"aws:SourceArn\": \"myRoute53ResourceArn\" }, \"StringEquals\": { \"aws:SourceAccount\":
\"myAwsAccountId\" } } } ] }
- `"policyName"`: Name of the new policy. This parameter is required.
"""
function put_resource_policy(; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"PutResourcePolicy"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function put_resource_policy(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutResourcePolicy", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
put_retention_policy(log_group_name, retention_in_days)
put_retention_policy(log_group_name, retention_in_days, params::Dict{String,<:Any})
Sets the retention of the specified log group. With a retention policy, you can configure
the number of days for which to retain log events in the specified log group. CloudWatch
Logs doesn’t immediately delete log events when they reach their retention setting. It
typically takes up to 72 hours after that before log events are deleted, but in rare
situations might take longer. To illustrate, imagine that you change a log group to have a
longer retention setting when it contains log events that are past the expiration date, but
haven’t been deleted. Those log events will take up to 72 hours to be deleted after the
new retention date is reached. To make sure that log data is deleted permanently, keep a
log group at its lower retention setting until 72 hours after the previous retention period
ends. Alternatively, wait to change the retention setting until you confirm that the
earlier log events are deleted. When log events reach their retention setting they are
marked for deletion. After they are marked for deletion, they do not add to your archival
storage costs anymore, even if they are not actually deleted until later. These log events
marked for deletion are also not included when you use an API to retrieve the storedBytes
value to see how many bytes a log group is storing.
# Arguments
- `log_group_name`: The name of the log group.
- `retention_in_days`:
"""
function put_retention_policy(
logGroupName, retentionInDays; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"PutRetentionPolicy",
Dict{String,Any}(
"logGroupName" => logGroupName, "retentionInDays" => retentionInDays
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_retention_policy(
logGroupName,
retentionInDays,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutRetentionPolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"logGroupName" => logGroupName, "retentionInDays" => retentionInDays
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_subscription_filter(destination_arn, filter_name, filter_pattern, log_group_name)
put_subscription_filter(destination_arn, filter_name, filter_pattern, log_group_name, params::Dict{String,<:Any})
Creates or updates a subscription filter and associates it with the specified log group.
With subscription filters, you can subscribe to a real-time stream of log events ingested
through PutLogEvents and have them delivered to a specific destination. When log events are
sent to the receiving service, they are Base64 encoded and compressed with the GZIP format.
The following destinations are supported for subscription filters: An Amazon Kinesis data
stream belonging to the same account as the subscription filter, for same-account delivery.
A logical destination created with PutDestination that belongs to a different account,
for cross-account delivery. We currently support Kinesis Data Streams and Firehose as
logical destinations. An Amazon Kinesis Data Firehose delivery stream that belongs to the
same account as the subscription filter, for same-account delivery. An Lambda function
that belongs to the same account as the subscription filter, for same-account delivery.
Each log group can have up to two subscription filters associated with it. If you are
updating an existing filter, you must specify the correct name in filterName. To perform a
PutSubscriptionFilter operation for any destination except a Lambda function, you must also
have the iam:PassRole permission.
# Arguments
- `destination_arn`: The ARN of the destination to deliver matching log events to.
Currently, the supported destinations are: An Amazon Kinesis stream belonging to the same
account as the subscription filter, for same-account delivery. A logical destination
(specified using an ARN) belonging to a different account, for cross-account delivery. If
you're setting up a cross-account subscription, the destination must have an IAM policy
associated with it. The IAM policy must allow the sender to send logs to the destination.
For more information, see PutDestinationPolicy. A Kinesis Data Firehose delivery stream
belonging to the same account as the subscription filter, for same-account delivery. A
Lambda function belonging to the same account as the subscription filter, for same-account
delivery.
- `filter_name`: A name for the subscription filter. If you are updating an existing
filter, you must specify the correct name in filterName. To find the name of the filter
currently associated with a log group, use DescribeSubscriptionFilters.
- `filter_pattern`: A filter pattern for subscribing to a filtered stream of log events.
- `log_group_name`: The name of the log group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"distribution"`: The method used to distribute log data to the destination. By default,
log data is grouped by log stream, but the grouping can be set to random for a more even
distribution. This property is only applicable when the destination is an Amazon Kinesis
data stream.
- `"roleArn"`: The ARN of an IAM role that grants CloudWatch Logs permissions to deliver
ingested log events to the destination stream. You don't need to provide the ARN when you
are working with a logical destination for cross-account delivery.
"""
function put_subscription_filter(
destinationArn,
filterName,
filterPattern,
logGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutSubscriptionFilter",
Dict{String,Any}(
"destinationArn" => destinationArn,
"filterName" => filterName,
"filterPattern" => filterPattern,
"logGroupName" => logGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_subscription_filter(
destinationArn,
filterName,
filterPattern,
logGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"PutSubscriptionFilter",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationArn" => destinationArn,
"filterName" => filterName,
"filterPattern" => filterPattern,
"logGroupName" => logGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_live_tail(log_group_identifiers)
start_live_tail(log_group_identifiers, params::Dict{String,<:Any})
Starts a Live Tail streaming session for one or more log groups. A Live Tail session
returns a stream of log events that have been recently ingested in the log groups. For more
information, see Use Live Tail to view logs in near real time. The response to this
operation is a response stream, over which the server sends live log events and the client
receives them. The following objects are sent over the stream: A single
LiveTailSessionStart object is sent at the start of the session. Every second, a
LiveTailSessionUpdate object is sent. Each of these objects contains an array of the actual
log events. If no new log events were ingested in the past second, the
LiveTailSessionUpdate object will contain an empty array. The array of log events contained
in a LiveTailSessionUpdate can include as many as 500 log events. If the number of log
events matching the request exceeds 500 per second, the log events are sampled down to 500
log events to be included in each LiveTailSessionUpdate object. If your client consumes the
log events slower than the server produces them, CloudWatch Logs buffers up to 10
LiveTailSessionUpdate events or 5000 log events, after which it starts dropping the oldest
events. A SessionStreamingException object is returned if an unknown error occurs on the
server side. A SessionTimeoutException object is returned when the session times out,
after it has been kept open for three hours. You can end a session before it times out
by closing the session stream or by closing the client that is receiving the stream. The
session also ends if the established connection between the client and the server breaks.
For examples of using an SDK to start a Live Tail session, see Start a Live Tail session
using an Amazon Web Services SDK.
# Arguments
- `log_group_identifiers`: An array where each item in the array is a log group to include
in the Live Tail session. Specify each log group by its ARN. If you specify an ARN, the
ARN can't end with an asterisk (*). You can include up to 10 log groups.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"logEventFilterPattern"`: An optional pattern to use to filter the results to include
only log events that match the pattern. For example, a filter pattern of error 404 causes
only log events that include both error and 404 to be included in the Live Tail stream.
Regular expression filter patterns are supported. For more information about filter pattern
syntax, see Filter and Pattern Syntax.
- `"logStreamNamePrefixes"`: If you specify this parameter, then only log events in the log
streams that have names that start with the prefixes that you specify here are included in
the Live Tail session. If you specify this field, you can't also specify the logStreamNames
field. You can specify this parameter only if you specify only one log group in
logGroupIdentifiers.
- `"logStreamNames"`: If you specify this parameter, then only log events in the log
streams that you specify here are included in the Live Tail session. If you specify this
field, you can't also specify the logStreamNamePrefixes field. You can specify this
parameter only if you specify only one log group in logGroupIdentifiers.
"""
function start_live_tail(
logGroupIdentifiers; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"StartLiveTail",
Dict{String,Any}("logGroupIdentifiers" => logGroupIdentifiers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_live_tail(
logGroupIdentifiers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"StartLiveTail",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("logGroupIdentifiers" => logGroupIdentifiers),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_query(end_time, query_string, start_time)
start_query(end_time, query_string, start_time, params::Dict{String,<:Any})
Schedules a query of a log group using CloudWatch Logs Insights. You specify the log group
and time range to query and the query string to use. For more information, see CloudWatch
Logs Insights Query Syntax. After you run a query using StartQuery, the query results are
stored by CloudWatch Logs. You can use GetQueryResults to retrieve the results of a query,
using the queryId that StartQuery returns. If you have associated a KMS key with the query
results in this account, then StartQuery uses that key to encrypt the results when it
stores them. If no key is associated with query results, the query results are encrypted
with the default CloudWatch Logs encryption method. Queries time out after 60 minutes of
runtime. If your queries are timing out, reduce the time range being searched or partition
your query into a number of queries. If you are using CloudWatch cross-account
observability, you can use this operation in a monitoring account to start a query in a
linked source account. For more information, see CloudWatch cross-account observability.
For a cross-account StartQuery operation, the query definition must be defined in the
monitoring account. You can have up to 30 concurrent CloudWatch Logs insights queries,
including queries that have been added to dashboards.
# Arguments
- `end_time`: The end of the time range to query. The range is inclusive, so the specified
end time is included in the query. Specified as epoch time, the number of seconds since
January 1, 1970, 00:00:00 UTC.
- `query_string`: The query string to use. For more information, see CloudWatch Logs
Insights Query Syntax.
- `start_time`: The beginning of the time range to query. The range is inclusive, so the
specified start time is included in the query. Specified as epoch time, the number of
seconds since January 1, 1970, 00:00:00 UTC.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"limit"`: The maximum number of log events to return in the query. If the query string
uses the fields command, only the specified fields and their values are returned. The
default is 1000.
- `"logGroupIdentifiers"`: The list of log groups to query. You can include up to 50 log
groups. You can specify them by the log group name or ARN. If a log group that you're
querying is in a source account and you're using a monitoring account, you must specify the
ARN of the log group here. The query definition must also be defined in the monitoring
account. If you specify an ARN, the ARN can't end with an asterisk (*). A StartQuery
operation must include exactly one of the following parameters: logGroupName,
logGroupNames, or logGroupIdentifiers.
- `"logGroupName"`: The log group on which to perform the query. A StartQuery operation
must include exactly one of the following parameters: logGroupName, logGroupNames, or
logGroupIdentifiers.
- `"logGroupNames"`: The list of log groups to be queried. You can include up to 50 log
groups. A StartQuery operation must include exactly one of the following parameters:
logGroupName, logGroupNames, or logGroupIdentifiers.
"""
function start_query(
endTime, queryString, startTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"StartQuery",
Dict{String,Any}(
"endTime" => endTime, "queryString" => queryString, "startTime" => startTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_query(
endTime,
queryString,
startTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"StartQuery",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"endTime" => endTime,
"queryString" => queryString,
"startTime" => startTime,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_query(query_id)
stop_query(query_id, params::Dict{String,<:Any})
Stops a CloudWatch Logs Insights query that is in progress. If the query has already ended,
the operation returns an error indicating that the specified query is not running.
# Arguments
- `query_id`: The ID number of the query to stop. To find this ID number, use
DescribeQueries.
"""
function stop_query(queryId; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"StopQuery",
Dict{String,Any}("queryId" => queryId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_query(
queryId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"StopQuery",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("queryId" => queryId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_log_group(log_group_name, tags)
tag_log_group(log_group_name, tags, params::Dict{String,<:Any})
The TagLogGroup operation is on the path to deprecation. We recommend that you use
TagResource instead. Adds or updates the specified tags for the specified log group. To
list the tags for a log group, use ListTagsForResource. To remove tags, use UntagResource.
For more information about tags, see Tag Log Groups in Amazon CloudWatch Logs in the Amazon
CloudWatch Logs User Guide. CloudWatch Logs doesn’t support IAM policies that prevent
users from assigning specified tags to log groups using the aws:Resource/key-name or
aws:TagKeys condition keys. For more information about using tags to control access, see
Controlling access to Amazon Web Services resources using tags.
# Arguments
- `log_group_name`: The name of the log group.
- `tags`: The key-value pairs to use for the tags.
"""
function tag_log_group(
logGroupName, tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"TagLogGroup",
Dict{String,Any}("logGroupName" => logGroupName, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_log_group(
logGroupName,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"TagLogGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("logGroupName" => logGroupName, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Assigns one or more tags (key-value pairs) to the specified CloudWatch Logs resource.
Currently, the only CloudWatch Logs resources that can be tagged are log groups and
destinations. Tags can help you organize and categorize your resources. You can also use
them to scope user permissions by granting a user permission to access or change only
resources with certain tag values. Tags don't have any semantic meaning to Amazon Web
Services and are interpreted strictly as strings of characters. You can use the TagResource
action with a resource that already has tags. If you specify a new tag key for the alarm,
this tag is appended to the list of tags associated with the alarm. If you specify a tag
key that is already associated with the alarm, the new tag value that you specify replaces
the previous value for that tag. You can associate as many as 50 tags with a CloudWatch
Logs resource.
# Arguments
- `resource_arn`: The ARN of the resource that you're adding tags to. The ARN format of a
log group is arn:aws:logs:Region:account-id:log-group:log-group-name The ARN format of a
destination is arn:aws:logs:Region:account-id:destination:destination-name For more
information about ARN format, see CloudWatch Logs resources and operations.
- `tags`: The list of key-value pairs to associate with the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return cloudwatch_logs(
"TagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_metric_filter(filter_pattern, log_event_messages)
test_metric_filter(filter_pattern, log_event_messages, params::Dict{String,<:Any})
Tests the filter pattern of a metric filter against a sample of log event messages. You can
use this operation to validate the correctness of a metric filter pattern.
# Arguments
- `filter_pattern`:
- `log_event_messages`: The log event messages to test.
"""
function test_metric_filter(
filterPattern, logEventMessages; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"TestMetricFilter",
Dict{String,Any}(
"filterPattern" => filterPattern, "logEventMessages" => logEventMessages
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_metric_filter(
filterPattern,
logEventMessages,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"TestMetricFilter",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filterPattern" => filterPattern, "logEventMessages" => logEventMessages
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_log_group(log_group_name, tags)
untag_log_group(log_group_name, tags, params::Dict{String,<:Any})
The UntagLogGroup operation is on the path to deprecation. We recommend that you use
UntagResource instead. Removes the specified tags from the specified log group. To list
the tags for a log group, use ListTagsForResource. To add tags, use TagResource. CloudWatch
Logs doesn’t support IAM policies that prevent users from assigning specified tags to log
groups using the aws:Resource/key-name or aws:TagKeys condition keys.
# Arguments
- `log_group_name`: The name of the log group.
- `tags`: The tag keys. The corresponding tags are removed from the log group.
"""
function untag_log_group(
logGroupName, tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"UntagLogGroup",
Dict{String,Any}("logGroupName" => logGroupName, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_log_group(
logGroupName,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"UntagLogGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("logGroupName" => logGroupName, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes one or more tags from the specified resource.
# Arguments
- `resource_arn`: The ARN of the CloudWatch Logs resource that you're removing tags from.
The ARN format of a log group is arn:aws:logs:Region:account-id:log-group:log-group-name
The ARN format of a destination is
arn:aws:logs:Region:account-id:destination:destination-name For more information about
ARN format, see CloudWatch Logs resources and operations.
- `tag_keys`: The list of tag keys to remove from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"UntagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_anomaly(anomaly_detector_arn)
update_anomaly(anomaly_detector_arn, params::Dict{String,<:Any})
Use this operation to suppress anomaly detection for a specified anomaly or pattern. If you
suppress an anomaly, CloudWatch Logs won’t report new occurrences of that anomaly and
won't update that anomaly with new data. If you suppress a pattern, CloudWatch Logs won’t
report any anomalies related to that pattern. You must specify either anomalyId or
patternId, but you can't specify both parameters in the same operation. If you have
previously used this operation to suppress detection of a pattern or anomaly, you can use
it again to cause CloudWatch Logs to end the suppression. To do this, use this operation
and specify the anomaly or pattern to stop suppressing, and omit the suppressionType and
suppressionPeriod parameters.
# Arguments
- `anomaly_detector_arn`: The ARN of the anomaly detector that this operation is to act on.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"anomalyId"`: If you are suppressing or unsuppressing an anomaly, specify its unique ID
here. You can find anomaly IDs by using the ListAnomalies operation.
- `"patternId"`: If you are suppressing or unsuppressing an pattern, specify its unique ID
here. You can find pattern IDs by using the ListAnomalies operation.
- `"suppressionPeriod"`: If you are temporarily suppressing an anomaly or pattern, use this
structure to specify how long the suppression is to last.
- `"suppressionType"`: Use this to specify whether the suppression to be temporary or
infinite. If you specify LIMITED, you must also specify a suppressionPeriod. If you specify
INFINITE, any value for suppressionPeriod is ignored.
"""
function update_anomaly(
anomalyDetectorArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"UpdateAnomaly",
Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_anomaly(
anomalyDetectorArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"UpdateAnomaly",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_log_anomaly_detector(anomaly_detector_arn, enabled)
update_log_anomaly_detector(anomaly_detector_arn, enabled, params::Dict{String,<:Any})
Updates an existing log anomaly detector.
# Arguments
- `anomaly_detector_arn`: The ARN of the anomaly detector that you want to update.
- `enabled`: Use this parameter to pause or restart the anomaly detector.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"anomalyVisibilityTime"`: The number of days to use as the life cycle of anomalies.
After this time, anomalies are automatically baselined and the anomaly detector model will
treat new occurrences of similar event as normal. Therefore, if you do not correct the
cause of an anomaly during this time, it will be considered normal going forward and will
not be detected.
- `"evaluationFrequency"`: Specifies how often the anomaly detector runs and look for
anomalies. Set this value according to the frequency that the log group receives new logs.
For example, if the log group receives new log events every 10 minutes, then setting
evaluationFrequency to FIFTEEN_MIN might be appropriate.
- `"filterPattern"`:
"""
function update_log_anomaly_detector(
anomalyDetectorArn, enabled; aws_config::AbstractAWSConfig=global_aws_config()
)
return cloudwatch_logs(
"UpdateLogAnomalyDetector",
Dict{String,Any}("anomalyDetectorArn" => anomalyDetectorArn, "enabled" => enabled);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_log_anomaly_detector(
anomalyDetectorArn,
enabled,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return cloudwatch_logs(
"UpdateLogAnomalyDetector",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"anomalyDetectorArn" => anomalyDetectorArn, "enabled" => enabled
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 109554 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codeartifact
using AWS.Compat
using AWS.UUIDs
"""
associate_external_connection(domain, external-connection, repository)
associate_external_connection(domain, external-connection, repository, params::Dict{String,<:Any})
Adds an existing external connection to a repository. One external connection is allowed
per repository. A repository can have one or more upstream repositories, or an external
connection.
# Arguments
- `domain`: The name of the domain that contains the repository.
- `external-connection`: The name of the external connection to add to the repository. The
following values are supported: public:npmjs - for the npm public repository.
public:nuget-org - for the NuGet Gallery. public:pypi - for the Python Package Index.
public:maven-central - for Maven Central. public:maven-googleandroid - for the Google
Android repository. public:maven-gradleplugins - for the Gradle plugins repository.
public:maven-commonsware - for the CommonsWare Android repository. public:maven-clojars
- for the Clojars repository. public:ruby-gems-org - for RubyGems.org.
public:crates-io - for Crates.io.
- `repository`: The name of the repository to which the external connection is added.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function associate_external_connection(
domain,
external_connection,
repository;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/repository/external-connection",
Dict{String,Any}(
"domain" => domain,
"external-connection" => external_connection,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_external_connection(
domain,
external_connection,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/repository/external-connection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"external-connection" => external_connection,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
copy_package_versions(destination-repository, domain, format, package, source-repository)
copy_package_versions(destination-repository, domain, format, package, source-repository, params::Dict{String,<:Any})
Copies package versions from one repository to another repository in the same domain.
You must specify versions or versionRevisions. You cannot specify both.
# Arguments
- `destination-repository`: The name of the repository into which package versions are
copied.
- `domain`: The name of the domain that contains the source and destination repositories.
- `format`: The format of the package versions to be copied.
- `package`: The name of the package that contains the versions to be copied.
- `source-repository`: The name of the repository that contains the package versions to be
copied.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"allowOverwrite"`: Set to true to overwrite a package version that already exists in
the destination repository. If set to false and the package version already exists in the
destination repository, the package version is returned in the failedVersions field of the
response with an ALREADY_EXISTS error code.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"includeFromUpstream"`: Set to true to copy packages from repositories that are
upstream from the source repository to the destination repository. The default setting is
false. For more information, see Working with upstream repositories.
- `"namespace"`: The namespace of the package versions to be copied. The package component
that specifies its namespace depends on its type. For example: The namespace is required
when copying package versions of the following formats: Maven Swift generic The
namespace of a Maven package version is its groupId. The namespace of an npm or Swift
package version is its scope. The namespace of a generic package is its namespace.
Python, NuGet, Ruby, and Cargo package versions do not contain a corresponding component,
package versions of those formats do not have a namespace.
- `"versionRevisions"`: A list of key-value pairs. The keys are package versions and the
values are package version revisions. A CopyPackageVersion operation succeeds if the
specified versions in the source repository match the specified package version revision.
You must specify versions or versionRevisions. You cannot specify both.
- `"versions"`: The versions of the package to be copied. You must specify versions or
versionRevisions. You cannot specify both.
"""
function copy_package_versions(
destination_repository,
domain,
format,
package,
source_repository;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/copy",
Dict{String,Any}(
"destination-repository" => destination_repository,
"domain" => domain,
"format" => format,
"package" => package,
"source-repository" => source_repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function copy_package_versions(
destination_repository,
domain,
format,
package,
source_repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/copy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destination-repository" => destination_repository,
"domain" => domain,
"format" => format,
"package" => package,
"source-repository" => source_repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_domain(domain)
create_domain(domain, params::Dict{String,<:Any})
Creates a domain. CodeArtifact domains make it easier to manage multiple repositories
across an organization. You can use a domain to apply permissions across many repositories
owned by different Amazon Web Services accounts. An asset is stored only once in a domain,
even if it's in multiple repositories. Although you can have multiple domains, we
recommend a single production domain that contains all published artifacts so that your
development teams can find and share packages. You can use a second pre-production domain
to test changes to the production domain configuration.
# Arguments
- `domain`: The name of the domain to create. All domain names in an Amazon Web Services
Region that are in the same Amazon Web Services account must be unique. The domain name is
used as the prefix in DNS hostnames. Do not use sensitive information in a domain name
because it is publicly discoverable.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"encryptionKey"`: The encryption key for the domain. This is used to encrypt content
stored in a domain. An encryption key can be a key ID, a key Amazon Resource Name (ARN), a
key alias, or a key alias ARN. To specify an encryptionKey, your IAM role must have
kms:DescribeKey and kms:CreateGrant permissions on the encryption key that is used. For
more information, see DescribeKey in the Key Management Service API Reference and Key
Management Service API Permissions Reference in the Key Management Service Developer Guide.
CodeArtifact supports only symmetric CMKs. Do not associate an asymmetric CMK with your
domain. For more information, see Using symmetric and asymmetric keys in the Key Management
Service Developer Guide.
- `"tags"`: One or more tag key-value pairs for the domain.
"""
function create_domain(domain; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST",
"/v1/domain",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_domain(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/domain",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_package_group(domain, package_group)
create_package_group(domain, package_group, params::Dict{String,<:Any})
Creates a package group. For more information about creating package groups, including
example CLI commands, see Create a package group in the CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain in which you want to create a package group.
- `package_group`: The pattern of the package group to create. The pattern is also the
identifier of the package group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contactInfo"`: The contact information for the created package group.
- `"description"`: A description of the package group.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"tags"`: One or more tag key-value pairs for the package group.
"""
function create_package_group(
domain, packageGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/package-group",
Dict{String,Any}("domain" => domain, "packageGroup" => packageGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_package_group(
domain,
packageGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "packageGroup" => packageGroup),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_repository(domain, repository)
create_repository(domain, repository, params::Dict{String,<:Any})
Creates a repository.
# Arguments
- `domain`: The name of the domain that contains the created repository.
- `repository`: The name of the repository to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A description of the created repository.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"tags"`: One or more tag key-value pairs for the repository.
- `"upstreams"`: A list of upstream repositories to associate with the repository. The
order of the upstream repositories in the list determines their priority order when
CodeArtifact looks for a requested package version. For more information, see Working with
upstream repositories.
"""
function create_repository(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/repository",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_repository(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/repository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain(domain)
delete_domain(domain, params::Dict{String,<:Any})
Deletes a domain. You cannot delete a domain that contains repositories. If you want to
delete a domain with repositories, first delete its repositories.
# Arguments
- `domain`: The name of the domain to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function delete_domain(domain; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"DELETE",
"/v1/domain",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/domain",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_domain_permissions_policy(domain)
delete_domain_permissions_policy(domain, params::Dict{String,<:Any})
Deletes the resource policy set on a domain.
# Arguments
- `domain`: The name of the domain associated with the resource policy to be deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"policy-revision"`: The current revision of the resource policy to be deleted. This
revision is used for optimistic locking, which prevents others from overwriting your
changes to the domain's resource policy.
"""
function delete_domain_permissions_policy(
domain; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/domain/permissions/policy",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_domain_permissions_policy(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/domain/permissions/policy",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_package(domain, format, package, repository)
delete_package(domain, format, package, repository, params::Dict{String,<:Any})
Deletes a package and all associated package versions. A deleted package cannot be
restored. To delete one or more package versions, use the DeletePackageVersions API.
# Arguments
- `domain`: The name of the domain that contains the package to delete.
- `format`: The format of the requested package to delete.
- `package`: The name of the package to delete.
- `repository`: The name of the repository that contains the package to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package to delete. The package component that
specifies its namespace depends on its type. For example: The namespace is required when
deleting packages of the following formats: Maven Swift generic The namespace
of a Maven package version is its groupId. The namespace of an npm or Swift package
version is its scope. The namespace of a generic package is its namespace. Python,
NuGet, Ruby, and Cargo package versions do not contain a corresponding component, package
versions of those formats do not have a namespace.
"""
function delete_package(
domain, format, package, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/package",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_package(
domain,
format,
package,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/package",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_package_group(domain, package-group)
delete_package_group(domain, package-group, params::Dict{String,<:Any})
Deletes a package group. Deleting a package group does not delete packages or package
versions associated with the package group. When a package group is deleted, the direct
child package groups will become children of the package group's direct parent package
group. Therefore, if any of the child groups are inheriting any settings from the parent,
those settings could change.
# Arguments
- `domain`: The domain that contains the package group to be deleted.
- `package-group`: The pattern of the package group to be deleted.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function delete_package_group(
domain, package_group; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/package-group",
Dict{String,Any}("domain" => domain, "package-group" => package_group);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_package_group(
domain,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/package-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "package-group" => package_group),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_package_versions(domain, format, package, repository, versions)
delete_package_versions(domain, format, package, repository, versions, params::Dict{String,<:Any})
Deletes one or more versions of a package. A deleted package version cannot be restored in
your repository. If you want to remove a package version from your repository and be able
to restore it later, set its status to Archived. Archived packages cannot be downloaded
from a repository and don't show up with list package APIs (for example,
ListPackageVersions), but you can restore them using UpdatePackageVersionsStatus.
# Arguments
- `domain`: The name of the domain that contains the package to delete.
- `format`: The format of the package versions to delete.
- `package`: The name of the package with the versions to delete.
- `repository`: The name of the repository that contains the package versions to delete.
- `versions`: An array of strings that specify the versions of the package to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"expectedStatus"`: The expected status of the package version to delete.
- `"namespace"`: The namespace of the package versions to be deleted. The package component
that specifies its namespace depends on its type. For example: The namespace is required
when deleting package versions of the following formats: Maven Swift generic
The namespace of a Maven package version is its groupId. The namespace of an npm or
Swift package version is its scope. The namespace of a generic package is its namespace.
Python, NuGet, Ruby, and Cargo package versions do not contain a corresponding
component, package versions of those formats do not have a namespace.
"""
function delete_package_versions(
domain,
format,
package,
repository,
versions;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/delete",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"versions" => versions,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_package_versions(
domain,
format,
package,
repository,
versions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/delete",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"versions" => versions,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_repository(domain, repository)
delete_repository(domain, repository, params::Dict{String,<:Any})
Deletes a repository.
# Arguments
- `domain`: The name of the domain that contains the repository to delete.
- `repository`: The name of the repository to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function delete_repository(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/repository",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_repository(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/repository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_repository_permissions_policy(domain, repository)
delete_repository_permissions_policy(domain, repository, params::Dict{String,<:Any})
Deletes the resource policy that is set on a repository. After a resource policy is
deleted, the permissions allowed and denied by the deleted policy are removed. The effect
of deleting a resource policy might not be immediate. Use
DeleteRepositoryPermissionsPolicy with caution. After a policy is deleted, Amazon Web
Services users, roles, and accounts lose permissions to perform the repository actions
granted by the deleted policy.
# Arguments
- `domain`: The name of the domain that contains the repository associated with the
resource policy to be deleted.
- `repository`: The name of the repository that is associated with the resource policy to
be deleted
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"policy-revision"`: The revision of the repository's resource policy to be deleted.
This revision is used for optimistic locking, which prevents others from accidentally
overwriting your changes to the repository's resource policy.
"""
function delete_repository_permissions_policy(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"DELETE",
"/v1/repository/permissions/policies",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_repository_permissions_policy(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/repository/permissions/policies",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_domain(domain)
describe_domain(domain, params::Dict{String,<:Any})
Returns a DomainDescription object that contains information about the requested domain.
# Arguments
- `domain`: A string that specifies the name of the requested domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function describe_domain(domain; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"GET",
"/v1/domain",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_domain(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/domain",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_package(domain, format, package, repository)
describe_package(domain, format, package, repository, params::Dict{String,<:Any})
Returns a PackageDescription object that contains information about the requested package.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the package.
- `format`: A format that specifies the type of the requested package.
- `package`: The name of the requested package.
- `repository`: The name of the repository that contains the requested package.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the requested package. The package component that
specifies its namespace depends on its type. For example: The namespace is required when
requesting packages of the following formats: Maven Swift generic The namespace
of a Maven package version is its groupId. The namespace of an npm or Swift package
version is its scope. The namespace of a generic package is its namespace. Python,
NuGet, Ruby, and Cargo package versions do not contain a corresponding component, package
versions of those formats do not have a namespace.
"""
function describe_package(
domain, format, package, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/package",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_package(
domain,
format,
package,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_package_group(domain, package-group)
describe_package_group(domain, package-group, params::Dict{String,<:Any})
Returns a PackageGroupDescription object that contains information about the requested
package group.
# Arguments
- `domain`: The name of the domain that contains the package group.
- `package-group`: The pattern of the requested package group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function describe_package_group(
domain, package_group; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/package-group",
Dict{String,Any}("domain" => domain, "package-group" => package_group);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_package_group(
domain,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "package-group" => package_group),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_package_version(domain, format, package, repository, version)
describe_package_version(domain, format, package, repository, version, params::Dict{String,<:Any})
Returns a PackageVersionDescription object that contains information about the requested
package version.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the package
version.
- `format`: A format that specifies the type of the requested package version.
- `package`: The name of the requested package version.
- `repository`: The name of the repository that contains the package version.
- `version`: A string that contains the package version (for example, 3.5.2).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the requested package version. The package component that
specifies its namespace depends on its type. For example: The namespace is required when
requesting package versions of the following formats: Maven Swift generic The
namespace of a Maven package version is its groupId. The namespace of an npm or Swift
package version is its scope. The namespace of a generic package is its namespace.
Python, NuGet, Ruby, and Cargo package versions do not contain a corresponding component,
package versions of those formats do not have a namespace.
"""
function describe_package_version(
domain,
format,
package,
repository,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_package_version(
domain,
format,
package,
repository,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_repository(domain, repository)
describe_repository(domain, repository, params::Dict{String,<:Any})
Returns a RepositoryDescription object that contains detailed information about the
requested repository.
# Arguments
- `domain`: The name of the domain that contains the repository to describe.
- `repository`: A string that specifies the name of the requested repository.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function describe_repository(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/repository",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_repository(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/repository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_external_connection(domain, external-connection, repository)
disassociate_external_connection(domain, external-connection, repository, params::Dict{String,<:Any})
Removes an existing external connection from a repository.
# Arguments
- `domain`: The name of the domain that contains the repository from which to remove the
external repository.
- `external-connection`: The name of the external connection to be removed from the
repository.
- `repository`: The name of the repository from which the external connection will be
removed.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function disassociate_external_connection(
domain,
external_connection,
repository;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/repository/external-connection",
Dict{String,Any}(
"domain" => domain,
"external-connection" => external_connection,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_external_connection(
domain,
external_connection,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"DELETE",
"/v1/repository/external-connection",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"external-connection" => external_connection,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
dispose_package_versions(domain, format, package, repository, versions)
dispose_package_versions(domain, format, package, repository, versions, params::Dict{String,<:Any})
Deletes the assets in package versions and sets the package versions' status to Disposed.
A disposed package version cannot be restored in your repository because its assets are
deleted. To view all disposed package versions in a repository, use ListPackageVersions
and set the status parameter to Disposed. To view information about a disposed package
version, use DescribePackageVersion.
# Arguments
- `domain`: The name of the domain that contains the repository you want to dispose.
- `format`: A format that specifies the type of package versions you want to dispose.
- `package`: The name of the package with the versions you want to dispose.
- `repository`: The name of the repository that contains the package versions you want to
dispose.
- `versions`: The versions of the package you want to dispose.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"expectedStatus"`: The expected status of the package version to dispose.
- `"namespace"`: The namespace of the package versions to be disposed. The package
component that specifies its namespace depends on its type. For example: The namespace is
required when disposing package versions of the following formats: Maven Swift
generic The namespace of a Maven package version is its groupId. The namespace of
an npm or Swift package version is its scope. The namespace of a generic package is its
namespace. Python, NuGet, Ruby, and Cargo package versions do not contain a
corresponding component, package versions of those formats do not have a namespace.
- `"versionRevisions"`: The revisions of the package versions you want to dispose.
"""
function dispose_package_versions(
domain,
format,
package,
repository,
versions;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/dispose",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"versions" => versions,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function dispose_package_versions(
domain,
format,
package,
repository,
versions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/dispose",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"versions" => versions,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_associated_package_group(domain, format, package)
get_associated_package_group(domain, format, package, params::Dict{String,<:Any})
Returns the most closely associated package group to the specified package. This API does
not require that the package exist in any repository in the domain. As such,
GetAssociatedPackageGroup can be used to see which package group's origin configuration
applies to a package before that package is in a repository. This can be helpful to check
if public packages are blocked without ingesting them. For information package group
association and matching, see Package group definition syntax and matching behavior in the
CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain that contains the package from which to get the
associated package group.
- `format`: The format of the package from which to get the associated package group.
- `package`: The package from which to get the associated package group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package from which to get the associated package
group. The package component that specifies its namespace depends on its type. For example:
The namespace is required when getting associated package groups from packages of the
following formats: Maven Swift generic The namespace of a Maven package version
is its groupId. The namespace of an npm or Swift package version is its scope. The
namespace of a generic package is its namespace. Python, NuGet, Ruby, and Cargo package
versions do not contain a corresponding component, package versions of those formats do not
have a namespace.
"""
function get_associated_package_group(
domain, format, package; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/get-associated-package-group",
Dict{String,Any}("domain" => domain, "format" => format, "package" => package);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_associated_package_group(
domain,
format,
package,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/get-associated-package-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain, "format" => format, "package" => package
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_authorization_token(domain)
get_authorization_token(domain, params::Dict{String,<:Any})
Generates a temporary authorization token for accessing repositories in the domain. This
API requires the codeartifact:GetAuthorizationToken and sts:GetServiceBearerToken
permissions. For more information about authorization tokens, see CodeArtifact
authentication and tokens. CodeArtifact authorization tokens are valid for a period of 12
hours when created with the login command. You can call login periodically to refresh the
token. When you create an authorization token with the GetAuthorizationToken API, you can
set a custom authorization period, up to a maximum of 12 hours, with the durationSeconds
parameter. The authorization period begins after login or GetAuthorizationToken is called.
If login or GetAuthorizationToken is called while assuming a role, the token lifetime is
independent of the maximum session duration of the role. For example, if you call sts
assume-role and specify a session duration of 15 minutes, then generate a CodeArtifact
authorization token, the token will be valid for the full authorization period even though
this is longer than the 15-minute session duration. See Using IAM Roles for more
information on controlling session duration.
# Arguments
- `domain`: The name of the domain that is in scope for the generated authorization token.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"duration"`: The time, in seconds, that the generated authorization token is valid.
Valid values are 0 and any number between 900 (15 minutes) and 43200 (12 hours). A value of
0 will set the expiration of the authorization token to the same expiration of the user's
role's temporary credentials.
"""
function get_authorization_token(domain; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST",
"/v1/authorization-token",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_authorization_token(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/authorization-token",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_domain_permissions_policy(domain)
get_domain_permissions_policy(domain, params::Dict{String,<:Any})
Returns the resource policy attached to the specified domain. The policy is a
resource-based policy, not an identity-based policy. For more information, see
Identity-based policies and resource-based policies in the IAM User Guide.
# Arguments
- `domain`: The name of the domain to which the resource policy is attached.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function get_domain_permissions_policy(
domain; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/domain/permissions/policy",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_domain_permissions_policy(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/domain/permissions/policy",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_package_version_asset(asset, domain, format, package, repository, version)
get_package_version_asset(asset, domain, format, package, repository, version, params::Dict{String,<:Any})
Returns an asset (or file) that is in a package. For example, for a Maven package version,
use GetPackageVersionAsset to download a JAR file, a POM file, or any other assets in the
package version.
# Arguments
- `asset`: The name of the requested asset.
- `domain`: The name of the domain that contains the repository that contains the package
version with the requested asset.
- `format`: A format that specifies the type of the package version with the requested
asset file.
- `package`: The name of the package that contains the requested asset.
- `repository`: The repository that contains the package version with the requested asset.
- `version`: A string that contains the package version (for example, 3.5.2).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package version with the requested asset file. The
package component that specifies its namespace depends on its type. For example: The
namespace is required when requesting assets from package versions of the following
formats: Maven Swift generic The namespace of a Maven package version is its
groupId. The namespace of an npm or Swift package version is its scope. The
namespace of a generic package is its namespace. Python, NuGet, Ruby, and Cargo package
versions do not contain a corresponding component, package versions of those formats do not
have a namespace.
- `"revision"`: The name of the package version revision that contains the requested
asset.
"""
function get_package_version_asset(
asset,
domain,
format,
package,
repository,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version/asset",
Dict{String,Any}(
"asset" => asset,
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_package_version_asset(
asset,
domain,
format,
package,
repository,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version/asset",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"asset" => asset,
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_package_version_readme(domain, format, package, repository, version)
get_package_version_readme(domain, format, package, repository, version, params::Dict{String,<:Any})
Gets the readme file or descriptive text for a package version. The returned text might
contain formatting. For example, it might contain formatting for Markdown or
reStructuredText.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the package
version with the requested readme file.
- `format`: A format that specifies the type of the package version with the requested
readme file.
- `package`: The name of the package version that contains the requested readme file.
- `repository`: The repository that contains the package with the requested readme file.
- `version`: A string that contains the package version (for example, 3.5.2).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package version with the requested readme file. The
package component that specifies its namespace depends on its type. For example: The
namespace is required when requesting the readme from package versions of the following
formats: Maven Swift generic The namespace of a Maven package version is its
groupId. The namespace of an npm or Swift package version is its scope. The
namespace of a generic package is its namespace. Python, NuGet, Ruby, and Cargo package
versions do not contain a corresponding component, package versions of those formats do not
have a namespace.
"""
function get_package_version_readme(
domain,
format,
package,
repository,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version/readme",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_package_version_readme(
domain,
format,
package,
repository,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package/version/readme",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository_endpoint(domain, format, repository)
get_repository_endpoint(domain, format, repository, params::Dict{String,<:Any})
Returns the endpoint of a repository for a specific package format. A repository has one
endpoint for each package format: cargo generic maven npm nuget
pypi ruby swift
# Arguments
- `domain`: The name of the domain that contains the repository.
- `format`: Returns which endpoint of a repository to return. A repository has one
endpoint for each package format.
- `repository`: The name of the repository.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain that contains the repository. It does not include dashes or spaces.
"""
function get_repository_endpoint(
domain, format, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/repository/endpoint",
Dict{String,Any}(
"domain" => domain, "format" => format, "repository" => repository
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository_endpoint(
domain,
format,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/repository/endpoint",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain, "format" => format, "repository" => repository
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository_permissions_policy(domain, repository)
get_repository_permissions_policy(domain, repository, params::Dict{String,<:Any})
Returns the resource policy that is set on a repository.
# Arguments
- `domain`: The name of the domain containing the repository whose associated resource
policy is to be retrieved.
- `repository`: The name of the repository whose associated resource policy is to be
retrieved.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function get_repository_permissions_policy(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/repository/permissions/policy",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository_permissions_policy(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/repository/permissions/policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_allowed_repositories_for_group(domain, origin_restriction_type, package-group)
list_allowed_repositories_for_group(domain, origin_restriction_type, package-group, params::Dict{String,<:Any})
Lists the repositories in the added repositories list of the specified restriction type for
a package group. For more information about restriction types and added repository lists,
see Package group origin controls in the CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain that contains the package group from which to list
allowed repositories.
- `origin_restriction_type`: The origin configuration restriction type of which to list
allowed repositories.
- `package-group`: The pattern of the package group from which to list allowed repositories.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_allowed_repositories_for_group(
domain,
originRestrictionType,
package_group;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package-group-allowed-repositories",
Dict{String,Any}(
"domain" => domain,
"originRestrictionType" => originRestrictionType,
"package-group" => package_group,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_allowed_repositories_for_group(
domain,
originRestrictionType,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/package-group-allowed-repositories",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"originRestrictionType" => originRestrictionType,
"package-group" => package_group,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_associated_packages(domain, package-group)
list_associated_packages(domain, package-group, params::Dict{String,<:Any})
Returns a list of packages associated with the requested package group. For information
package group association and matching, see Package group definition syntax and matching
behavior in the CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain that contains the package group from which to list
associated packages.
- `package-group`: The pattern of the package group from which to list associated
packages.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"preview"`: When this flag is included, ListAssociatedPackages will return a list of
packages that would be associated with a package group, even if it does not exist.
"""
function list_associated_packages(
domain, package_group; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"GET",
"/v1/list-associated-packages",
Dict{String,Any}("domain" => domain, "package-group" => package_group);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_associated_packages(
domain,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"GET",
"/v1/list-associated-packages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "package-group" => package_group),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_domains()
list_domains(params::Dict{String,<:Any})
Returns a list of DomainSummary objects for all domains owned by the Amazon Web Services
account that makes this call. Each returned DomainSummary object contains information about
a domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return per page.
- `"nextToken"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_domains(; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST", "/v1/domains"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_domains(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/domains",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_package_groups(domain)
list_package_groups(domain, params::Dict{String,<:Any})
Returns a list of package groups in the requested domain.
# Arguments
- `domain`: The domain for which you want to list package groups.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"prefix"`: A prefix for which to search package groups. When included,
ListPackageGroups will return only package groups with patterns that match the prefix.
"""
function list_package_groups(domain; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST",
"/v1/package-groups",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_package_groups(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/package-groups",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_package_version_assets(domain, format, package, repository, version)
list_package_version_assets(domain, format, package, repository, version, params::Dict{String,<:Any})
Returns a list of AssetSummary objects for assets in a package version.
# Arguments
- `domain`: The name of the domain that contains the repository associated with the
package version assets.
- `format`: The format of the package that contains the requested package version assets.
- `package`: The name of the package that contains the requested package version assets.
- `repository`: The name of the repository that contains the package that contains the
requested package version assets.
- `version`: A string that contains the package version (for example, 3.5.2).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"namespace"`: The namespace of the package version that contains the requested package
version assets. The package component that specifies its namespace depends on its type. For
example: The namespace is required requesting assets from package versions of the
following formats: Maven Swift generic The namespace of a Maven package version
is its groupId. The namespace of an npm or Swift package version is its scope. The
namespace of a generic package is its namespace. Python, NuGet, Ruby, and Cargo package
versions do not contain a corresponding component, package versions of those formats do not
have a namespace.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_package_version_assets(
domain,
format,
package,
repository,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/assets",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_package_version_assets(
domain,
format,
package,
repository,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/assets",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_package_version_dependencies(domain, format, package, repository, version)
list_package_version_dependencies(domain, format, package, repository, version, params::Dict{String,<:Any})
Returns the direct dependencies for a package version. The dependencies are returned as
PackageDependency objects. CodeArtifact extracts the dependencies for a package version
from the metadata file for the package format (for example, the package.json file for npm
packages and the pom.xml file for Maven). Any package version dependencies that are not
listed in the configuration file are not returned.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the
requested package version dependencies.
- `format`: The format of the package with the requested dependencies.
- `package`: The name of the package versions' package.
- `repository`: The name of the repository that contains the requested package version.
- `version`: A string that contains the package version (for example, 3.5.2).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package version with the requested dependencies. The
package component that specifies its namespace depends on its type. For example: The
namespace is required when listing dependencies from package versions of the following
formats: Maven The namespace of a Maven package version is its groupId. The
namespace of an npm package version is its scope. Python and NuGet package versions do
not contain a corresponding component, package versions of those formats do not have a
namespace.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_package_version_dependencies(
domain,
format,
package,
repository,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/dependencies",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_package_version_dependencies(
domain,
format,
package,
repository,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/dependencies",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_package_versions(domain, format, package, repository)
list_package_versions(domain, format, package, repository, params::Dict{String,<:Any})
Returns a list of PackageVersionSummary objects for package versions in a repository that
match the request parameters. Package versions of all statuses will be returned by default
when calling list-package-versions with no --status parameter.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the
requested package versions.
- `format`: The format of the package versions you want to list.
- `package`: The name of the package for which you want to request package versions.
- `repository`: The name of the repository that contains the requested package versions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"namespace"`: The namespace of the package that contains the requested package versions.
The package component that specifies its namespace depends on its type. For example: The
namespace is required when deleting package versions of the following formats: Maven
Swift generic The namespace of a Maven package version is its groupId. The
namespace of an npm or Swift package version is its scope. The namespace of a generic
package is its namespace. Python, NuGet, Ruby, and Cargo package versions do not contain
a corresponding component, package versions of those formats do not have a namespace.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"originType"`: The originType used to filter package versions. Only package versions
with the provided originType will be returned.
- `"sortBy"`: How to sort the requested list of package versions.
- `"status"`: A string that filters the requested package versions by status.
"""
function list_package_versions(
domain, format, package, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/package/versions",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_package_versions(
domain,
format,
package,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_packages(domain, repository)
list_packages(domain, repository, params::Dict{String,<:Any})
Returns a list of PackageSummary objects for packages in a repository that match the
request parameters.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the
requested packages.
- `repository`: The name of the repository that contains the requested packages.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"format"`: The format used to filter requested packages. Only packages from the provided
format will be returned.
- `"max-results"`: The maximum number of results to return per page.
- `"namespace"`: The namespace prefix used to filter requested packages. Only packages with
a namespace that starts with the provided string value are returned. Note that although
this option is called --namespace and not --namespace-prefix, it has prefix-matching
behavior. Each package format uses namespace as follows: The namespace of a Maven
package version is its groupId. The namespace of an npm or Swift package version is its
scope. The namespace of a generic package is its namespace. Python, NuGet, Ruby, and
Cargo package versions do not contain a corresponding component, package versions of those
formats do not have a namespace.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"package-prefix"`: A prefix used to filter requested packages. Only packages with names
that start with packagePrefix are returned.
- `"publish"`: The value of the Publish package origin control restriction used to filter
requested packages. Only packages with the provided restriction are returned. For more
information, see PackageOriginRestrictions.
- `"upstream"`: The value of the Upstream package origin control restriction used to filter
requested packages. Only packages with the provided restriction are returned. For more
information, see PackageOriginRestrictions.
"""
function list_packages(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/packages",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_packages(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/packages",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_repositories()
list_repositories(params::Dict{String,<:Any})
Returns a list of RepositorySummary objects. Each RepositorySummary contains information
about a repository in the specified Amazon Web Services account and that matches the input
parameters.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"repository-prefix"`: A prefix used to filter returned repositories. Only repositories
with names that start with repositoryPrefix are returned.
"""
function list_repositories(; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST", "/v1/repositories"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_repositories(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/repositories",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_repositories_in_domain(domain)
list_repositories_in_domain(domain, params::Dict{String,<:Any})
Returns a list of RepositorySummary objects. Each RepositorySummary contains information
about a repository in the specified domain and that matches the input parameters.
# Arguments
- `domain`: The name of the domain that contains the returned list of repositories.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"administrator-account"`: Filter the list of repositories to only include those that
are managed by the Amazon Web Services account ID.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
- `"repository-prefix"`: A prefix used to filter returned repositories. Only repositories
with names that start with repositoryPrefix are returned.
"""
function list_repositories_in_domain(
domain; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/domain/repositories",
Dict{String,Any}("domain" => domain);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_repositories_in_domain(
domain, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/domain/repositories",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("domain" => domain), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sub_package_groups(domain, package-group)
list_sub_package_groups(domain, package-group, params::Dict{String,<:Any})
Returns a list of direct children of the specified package group. For information package
group hierarchy, see Package group definition syntax and matching behavior in the
CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain which contains the package group from which to list sub
package groups.
- `package-group`: The pattern of the package group from which to list sub package groups.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"max-results"`: The maximum number of results to return per page.
- `"next-token"`: The token for the next set of results. Use the value returned in the
previous response in the next request to retrieve the next set of results.
"""
function list_sub_package_groups(
domain, package_group; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/package-groups/sub-groups",
Dict{String,Any}("domain" => domain, "package-group" => package_group);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sub_package_groups(
domain,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package-groups/sub-groups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "package-group" => package_group),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Gets information about Amazon Web Services tags for a specified Amazon Resource Name (ARN)
in CodeArtifact.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to get tags for.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/tags",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/tags",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
publish_package_version(asset, asset_content, domain, format, package, repository, version, x-amz-content-sha256)
publish_package_version(asset, asset_content, domain, format, package, repository, version, x-amz-content-sha256, params::Dict{String,<:Any})
Creates a new package version containing one or more assets (or files). The unfinished flag
can be used to keep the package version in the Unfinished state until all of its assets
have been uploaded (see Package version status in the CodeArtifact user guide). To set the
package version’s status to Published, omit the unfinished flag when uploading the final
asset, or set the status using UpdatePackageVersionStatus. Once a package version’s
status is set to Published, it cannot change back to Unfinished. Only generic packages can
be published using this API. For more information, see Using generic packages in the
CodeArtifact User Guide.
# Arguments
- `asset`: The name of the asset to publish. Asset names can include Unicode letters and
numbers, and the following special characters: ~ ! @ ^ & ( ) - ` _ + [ ] { } ; , . `
- `asset_content`: The content of the asset to publish.
- `domain`: The name of the domain that contains the repository that contains the package
version to publish.
- `format`: A format that specifies the type of the package version with the requested
asset file. The only supported value is generic.
- `package`: The name of the package version to publish.
- `repository`: The name of the repository that the package version will be published to.
- `version`: The package version to publish (for example, 3.5.2).
- `x-amz-content-sha256`: The SHA256 hash of the assetContent to publish. This value must
be calculated by the caller and provided with the request (see Publishing a generic package
in the CodeArtifact User Guide). This value is used as an integrity check to verify that
the assetContent has not changed after it was originally sent.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the AWS account that owns the domain. It
does not include dashes or spaces.
- `"namespace"`: The namespace of the package version to publish.
- `"unfinished"`: Specifies whether the package version should remain in the unfinished
state. If omitted, the package version status will be set to Published (see Package version
status in the CodeArtifact User Guide). Valid values: unfinished
"""
function publish_package_version(
asset,
assetContent,
domain,
format,
package,
repository,
version,
x_amz_content_sha256;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/publish",
Dict{String,Any}(
"asset" => asset,
"assetContent" => assetContent,
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
"headers" => Dict{String,Any}("x-amz-content-sha256" => x_amz_content_sha256),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function publish_package_version(
asset,
assetContent,
domain,
format,
package,
repository,
version,
x_amz_content_sha256,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/version/publish",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"asset" => asset,
"assetContent" => assetContent,
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"version" => version,
"headers" =>
Dict{String,Any}("x-amz-content-sha256" => x_amz_content_sha256),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_domain_permissions_policy(domain, policy_document)
put_domain_permissions_policy(domain, policy_document, params::Dict{String,<:Any})
Sets a resource policy on a domain that specifies permissions to access it. When you
call PutDomainPermissionsPolicy, the resource policy on the domain is ignored when
evaluting permissions. This ensures that the owner of a domain cannot lock themselves out
of the domain, which would prevent them from being able to update the resource policy.
# Arguments
- `domain`: The name of the domain on which to set the resource policy.
- `policy_document`: A valid displayable JSON Aspen policy string to be set as the access
control resource policy on the provided domain.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainOwner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"policyRevision"`: The current revision of the resource policy to be set. This revision
is used for optimistic locking, which prevents others from overwriting your changes to the
domain's resource policy.
"""
function put_domain_permissions_policy(
domain, policyDocument; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"PUT",
"/v1/domain/permissions/policy",
Dict{String,Any}("domain" => domain, "policyDocument" => policyDocument);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_domain_permissions_policy(
domain,
policyDocument,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"PUT",
"/v1/domain/permissions/policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "policyDocument" => policyDocument),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_package_origin_configuration(domain, format, package, repository, restrictions)
put_package_origin_configuration(domain, format, package, repository, restrictions, params::Dict{String,<:Any})
Sets the package origin configuration for a package. The package origin configuration
determines how new versions of a package can be added to a repository. You can allow or
block direct publishing of new package versions, or ingestion and retaining of new package
versions from an external connection or upstream source. For more information about package
origin controls and configuration, see Editing package origin controls in the CodeArtifact
User Guide. PutPackageOriginConfiguration can be called on a package that doesn't yet
exist in the repository. When called on a package that does not exist, a package is created
in the repository with no versions and the requested restrictions are set on the package.
This can be used to preemptively block ingesting or retaining any versions from external
connections or upstream repositories, or to block publishing any versions of the package
into the repository before connecting any package managers or publishers to the repository.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the package.
- `format`: A format that specifies the type of the package to be updated.
- `package`: The name of the package to be updated.
- `repository`: The name of the repository that contains the package.
- `restrictions`: A PackageOriginRestrictions object that contains information about the
upstream and publish package origin restrictions. The upstream restriction determines if
new package versions can be ingested or retained from external connections or upstream
repositories. The publish restriction determines if new package versions can be published
directly to the repository. You must include both the desired upstream and publish
restrictions.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"namespace"`: The namespace of the package to be updated. The package component that
specifies its namespace depends on its type. For example: The namespace of a Maven
package version is its groupId. The namespace of an npm or Swift package version is its
scope. The namespace of a generic package is its namespace. Python, NuGet, Ruby, and
Cargo package versions do not contain a corresponding component, package versions of those
formats do not have a namespace.
"""
function put_package_origin_configuration(
domain,
format,
package,
repository,
restrictions;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"restrictions" => restrictions,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_package_origin_configuration(
domain,
format,
package,
repository,
restrictions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"restrictions" => restrictions,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_repository_permissions_policy(domain, policy_document, repository)
put_repository_permissions_policy(domain, policy_document, repository, params::Dict{String,<:Any})
Sets the resource policy on a repository that specifies permissions to access it. When
you call PutRepositoryPermissionsPolicy, the resource policy on the repository is ignored
when evaluting permissions. This ensures that the owner of a repository cannot lock
themselves out of the repository, which would prevent them from being able to update the
resource policy.
# Arguments
- `domain`: The name of the domain containing the repository to set the resource policy
on.
- `policy_document`: A valid displayable JSON Aspen policy string to be set as the access
control resource policy on the provided repository.
- `repository`: The name of the repository to set the resource policy on.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"policyRevision"`: Sets the revision of the resource policy that specifies permissions
to access the repository. This revision is used for optimistic locking, which prevents
others from overwriting your changes to the repository's resource policy.
"""
function put_repository_permissions_policy(
domain, policyDocument, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"PUT",
"/v1/repository/permissions/policy",
Dict{String,Any}(
"domain" => domain,
"policyDocument" => policyDocument,
"repository" => repository,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_repository_permissions_policy(
domain,
policyDocument,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"PUT",
"/v1/repository/permissions/policy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"policyDocument" => policyDocument,
"repository" => repository,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds or updates tags for a resource in CodeArtifact.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to add or
update tags for.
- `tags`: The tags you want to modify or add to the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return codeartifact(
"POST",
"/v1/tag",
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/tag",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from a resource in CodeArtifact.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that you want to remove
tags from.
- `tag_keys`: The tag key for each tag that you want to remove from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"POST",
"/v1/untag",
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/untag",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_package_group(domain, package_group)
update_package_group(domain, package_group, params::Dict{String,<:Any})
Updates a package group. This API cannot be used to update a package group's origin
configuration or pattern. To update a package group's origin configuration, use
UpdatePackageGroupOriginConfiguration.
# Arguments
- `domain`: The name of the domain which contains the package group to be updated.
- `package_group`: The pattern of the package group to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"contactInfo"`: Contact information which you want to update the requested package
group with.
- `"description"`: The description you want to update the requested package group with.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
"""
function update_package_group(
domain, packageGroup; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"PUT",
"/v1/package-group",
Dict{String,Any}("domain" => domain, "packageGroup" => packageGroup);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_package_group(
domain,
packageGroup,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"PUT",
"/v1/package-group",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "packageGroup" => packageGroup),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_package_group_origin_configuration(domain, package-group)
update_package_group_origin_configuration(domain, package-group, params::Dict{String,<:Any})
Updates the package origin configuration for a package group. The package origin
configuration determines how new versions of a package can be added to a repository. You
can allow or block direct publishing of new package versions, or ingestion and retaining of
new package versions from an external connection or upstream source. For more information
about package group origin controls and configuration, see Package group origin controls in
the CodeArtifact User Guide.
# Arguments
- `domain`: The name of the domain which contains the package group for which to update
the origin configuration.
- `package-group`: The pattern of the package group for which to update the origin
configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"addAllowedRepositories"`: The repository name and restrictions to add to the allowed
repository list of the specified package group.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"removeAllowedRepositories"`: The repository name and restrictions to remove from the
allowed repository list of the specified package group.
- `"restrictions"`: The origin configuration settings that determine how package versions
can enter repositories.
"""
function update_package_group_origin_configuration(
domain, package_group; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"PUT",
"/v1/package-group-origin-configuration",
Dict{String,Any}("domain" => domain, "package-group" => package_group);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_package_group_origin_configuration(
domain,
package_group,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"PUT",
"/v1/package-group-origin-configuration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "package-group" => package_group),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_package_versions_status(domain, format, package, repository, target_status, versions)
update_package_versions_status(domain, format, package, repository, target_status, versions, params::Dict{String,<:Any})
Updates the status of one or more versions of a package. Using
UpdatePackageVersionsStatus, you can update the status of package versions to Archived,
Published, or Unlisted. To set the status of a package version to Disposed, use
DisposePackageVersions.
# Arguments
- `domain`: The name of the domain that contains the repository that contains the package
versions with a status to be updated.
- `format`: A format that specifies the type of the package with the statuses to update.
- `package`: The name of the package with the version statuses to update.
- `repository`: The repository that contains the package versions with the status you want
to update.
- `target_status`: The status you want to change the package version status to.
- `versions`: An array of strings that specify the versions of the package with the
statuses to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"expectedStatus"`: The package version’s expected status before it is updated. If
expectedStatus is provided, the package version's status is updated only if its status at
the time UpdatePackageVersionsStatus is called matches expectedStatus.
- `"namespace"`: The namespace of the package version to be updated. The package component
that specifies its namespace depends on its type. For example: The namespace of a Maven
package version is its groupId. The namespace of an npm or Swift package version is its
scope. The namespace of a generic package is its namespace. Python, NuGet, Ruby, and
Cargo package versions do not contain a corresponding component, package versions of those
formats do not have a namespace.
- `"versionRevisions"`: A map of package versions and package version revisions. The map
key is the package version (for example, 3.5.2), and the map value is the package version
revision.
"""
function update_package_versions_status(
domain,
format,
package,
repository,
targetStatus,
versions;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/update_status",
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"targetStatus" => targetStatus,
"versions" => versions,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_package_versions_status(
domain,
format,
package,
repository,
targetStatus,
versions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"POST",
"/v1/package/versions/update_status",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"domain" => domain,
"format" => format,
"package" => package,
"repository" => repository,
"targetStatus" => targetStatus,
"versions" => versions,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_repository(domain, repository)
update_repository(domain, repository, params::Dict{String,<:Any})
Update the properties of a repository.
# Arguments
- `domain`: The name of the domain associated with the repository to update.
- `repository`: The name of the repository to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: An updated repository description.
- `"domain-owner"`: The 12-digit account number of the Amazon Web Services account that
owns the domain. It does not include dashes or spaces.
- `"upstreams"`: A list of upstream repositories to associate with the repository. The
order of the upstream repositories in the list determines their priority order when
CodeArtifact looks for a requested package version. For more information, see Working with
upstream repositories.
"""
function update_repository(
domain, repository; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeartifact(
"PUT",
"/v1/repository",
Dict{String,Any}("domain" => domain, "repository" => repository);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_repository(
domain,
repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeartifact(
"PUT",
"/v1/repository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("domain" => domain, "repository" => repository),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 99030 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codebuild
using AWS.Compat
using AWS.UUIDs
"""
batch_delete_builds(ids)
batch_delete_builds(ids, params::Dict{String,<:Any})
Deletes one or more builds.
# Arguments
- `ids`: The IDs of the builds to delete.
"""
function batch_delete_builds(ids; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchDeleteBuilds",
Dict{String,Any}("ids" => ids);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_delete_builds(
ids, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchDeleteBuilds",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("ids" => ids), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_build_batches(ids)
batch_get_build_batches(ids, params::Dict{String,<:Any})
Retrieves information about one or more batch builds.
# Arguments
- `ids`: An array that contains the batch build identifiers to retrieve.
"""
function batch_get_build_batches(ids; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchGetBuildBatches",
Dict{String,Any}("ids" => ids);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_build_batches(
ids, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchGetBuildBatches",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("ids" => ids), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_builds(ids)
batch_get_builds(ids, params::Dict{String,<:Any})
Gets information about one or more builds.
# Arguments
- `ids`: The IDs of the builds.
"""
function batch_get_builds(ids; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchGetBuilds",
Dict{String,Any}("ids" => ids);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_builds(
ids, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchGetBuilds",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("ids" => ids), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_fleets(names)
batch_get_fleets(names, params::Dict{String,<:Any})
Gets information about one or more compute fleets.
# Arguments
- `names`: The names or ARNs of the compute fleets.
"""
function batch_get_fleets(names; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchGetFleets",
Dict{String,Any}("names" => names);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_fleets(
names, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchGetFleets",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("names" => names), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_projects(names)
batch_get_projects(names, params::Dict{String,<:Any})
Gets information about one or more build projects.
# Arguments
- `names`: The names or ARNs of the build projects. To get information about a project
shared with your Amazon Web Services account, its ARN must be specified. You cannot specify
a shared project using its name.
"""
function batch_get_projects(names; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchGetProjects",
Dict{String,Any}("names" => names);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_projects(
names, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchGetProjects",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("names" => names), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_report_groups(report_group_arns)
batch_get_report_groups(report_group_arns, params::Dict{String,<:Any})
Returns an array of report groups.
# Arguments
- `report_group_arns`: An array of report group ARNs that identify the report groups to
return.
"""
function batch_get_report_groups(
reportGroupArns; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"BatchGetReportGroups",
Dict{String,Any}("reportGroupArns" => reportGroupArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_report_groups(
reportGroupArns,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"BatchGetReportGroups",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("reportGroupArns" => reportGroupArns), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_reports(report_arns)
batch_get_reports(report_arns, params::Dict{String,<:Any})
Returns an array of reports.
# Arguments
- `report_arns`: An array of ARNs that identify the Report objects to return.
"""
function batch_get_reports(reportArns; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"BatchGetReports",
Dict{String,Any}("reportArns" => reportArns);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_reports(
reportArns,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"BatchGetReports",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportArns" => reportArns), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_fleet(base_capacity, compute_type, environment_type, name)
create_fleet(base_capacity, compute_type, environment_type, name, params::Dict{String,<:Any})
Creates a compute fleet.
# Arguments
- `base_capacity`: The initial number of machines allocated to the fleet, which defines
the number of builds that can run in parallel.
- `compute_type`: Information about the compute resources the compute fleet uses. Available
values include: BUILD_GENERAL1_SMALL: Use up to 3 GB memory and 2 vCPUs for builds.
BUILD_GENERAL1_MEDIUM: Use up to 7 GB memory and 4 vCPUs for builds.
BUILD_GENERAL1_LARGE: Use up to 16 GB memory and 8 vCPUs for builds, depending on your
environment type. BUILD_GENERAL1_XLARGE: Use up to 70 GB memory and 36 vCPUs for builds,
depending on your environment type. BUILD_GENERAL1_2XLARGE: Use up to 145 GB memory, 72
vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to
100 GB uncompressed. If you use BUILD_GENERAL1_SMALL: For environment type
LINUX_CONTAINER, you can use up to 3 GB memory and 2 vCPUs for builds. For environment
type LINUX_GPU_CONTAINER, you can use up to 16 GB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor
Core GPU for builds. For environment type ARM_CONTAINER, you can use up to 4 GB memory
and 2 vCPUs on ARM-based processors for builds. If you use BUILD_GENERAL1_LARGE: For
environment type LINUX_CONTAINER, you can use up to 15 GB memory and 8 vCPUs for builds.
For environment type LINUX_GPU_CONTAINER, you can use up to 255 GB memory, 32 vCPUs, and 4
NVIDIA Tesla V100 GPUs for builds. For environment type ARM_CONTAINER, you can use up to
16 GB memory and 8 vCPUs on ARM-based processors for builds. For more information, see
Build environment compute types in the CodeBuild User Guide.
- `environment_type`: The environment type of the compute fleet. The environment type
ARM_CONTAINER is available only in regions US East (N. Virginia), US East (Ohio), US West
(Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific
(Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). The
environment type LINUX_CONTAINER is available only in regions US East (N. Virginia), US
East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia
Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific
(Mumbai). The environment type LINUX_GPU_CONTAINER is available only in regions US East
(N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
(Tokyo), and Asia Pacific (Sydney). The environment type WINDOWS_SERVER_2019_CONTAINER is
available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia
Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). The
environment type WINDOWS_SERVER_2022_CONTAINER is available only in regions US East (N.
Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
(Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and
Asia Pacific (Mumbai). For more information, see Build environment compute types in the
CodeBuild user guide.
- `name`: The name of the compute fleet.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"fleetServiceRole"`: The service role associated with the compute fleet. For more
information, see Allow a user to add a permission policy for a fleet service role in the
CodeBuild User Guide.
- `"overflowBehavior"`: The compute fleet overflow behavior. For overflow behavior QUEUE,
your overflow builds need to wait on the existing fleet instance to become available. For
overflow behavior ON_DEMAND, your overflow builds run on CodeBuild on-demand. If you
choose to set your overflow behavior to on-demand while creating a VPC-connected fleet,
make sure that you add the required VPC permissions to your project service role. For more
information, see Example policy statement to allow CodeBuild access to Amazon Web Services
services required to create a VPC network interface.
- `"scalingConfiguration"`: The scaling configuration of the compute fleet.
- `"tags"`: A list of tag key and value pairs associated with this compute fleet. These
tags are available for use by Amazon Web Services services that support CodeBuild build
project tags.
- `"vpcConfig"`:
"""
function create_fleet(
baseCapacity,
computeType,
environmentType,
name;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateFleet",
Dict{String,Any}(
"baseCapacity" => baseCapacity,
"computeType" => computeType,
"environmentType" => environmentType,
"name" => name,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_fleet(
baseCapacity,
computeType,
environmentType,
name,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateFleet",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"baseCapacity" => baseCapacity,
"computeType" => computeType,
"environmentType" => environmentType,
"name" => name,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_project(artifacts, environment, name, service_role, source)
create_project(artifacts, environment, name, service_role, source, params::Dict{String,<:Any})
Creates a build project.
# Arguments
- `artifacts`: Information about the build output artifacts for the build project.
- `environment`: Information about the build environment for the build project.
- `name`: The name of the build project.
- `service_role`: The ARN of the IAM role that enables CodeBuild to interact with dependent
Amazon Web Services services on behalf of the Amazon Web Services account.
- `source`: Information about the build input source code for the build project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"badgeEnabled"`: Set this to true to generate a publicly accessible URL for your
project's build badge.
- `"buildBatchConfig"`: A ProjectBuildBatchConfig object that defines the batch build
options for the project.
- `"cache"`: Stores recently used information so that it can be quickly accessed at a later
time.
- `"concurrentBuildLimit"`: The maximum number of concurrent builds that are allowed for
this project. New builds are only started if the current number of builds is less than or
equal to this limit. If the current build count meets this limit, new builds are throttled
and are not run.
- `"description"`: A description that makes the build project easy to identify.
- `"encryptionKey"`: The Key Management Service customer master key (CMK) to be used for
encrypting the build output artifacts. You can use a cross-account KMS key to encrypt the
build output artifacts if your service role has permission to that key. You can specify
either the Amazon Resource Name (ARN) of the CMK or, if available, the CMK's alias (using
the format alias/<alias-name>).
- `"fileSystemLocations"`: An array of ProjectFileSystemLocation objects for a CodeBuild
build project. A ProjectFileSystemLocation object specifies the identifier, location,
mountOptions, mountPoint, and type of a file system created using Amazon Elastic File
System.
- `"logsConfig"`: Information about logs for the build project. These can be logs in
CloudWatch Logs, logs uploaded to a specified S3 bucket, or both.
- `"queuedTimeoutInMinutes"`: The number of minutes a build is allowed to be queued before
it times out.
- `"secondaryArtifacts"`: An array of ProjectArtifacts objects.
- `"secondarySourceVersions"`: An array of ProjectSourceVersion objects. If
secondarySourceVersions is specified at the build level, then they take precedence over
these secondarySourceVersions (at the project level).
- `"secondarySources"`: An array of ProjectSource objects.
- `"sourceVersion"`: A version of the build input to be built for this project. If not
specified, the latest version is used. If specified, it must be one of: For CodeCommit:
the commit ID, branch, or Git tag to use. For GitHub: the commit ID, pull request ID,
branch name, or tag name that corresponds to the version of the source code you want to
build. If a pull request ID is specified, it must use the format pr/pull-request-ID (for
example pr/25). If a branch name is specified, the branch's HEAD commit ID is used. If not
specified, the default branch's HEAD commit ID is used. For GitLab: the commit ID,
branch, or Git tag to use. For Bitbucket: the commit ID, branch name, or tag name that
corresponds to the version of the source code you want to build. If a branch name is
specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD
commit ID is used. For Amazon S3: the version ID of the object that represents the build
input ZIP file to use. If sourceVersion is specified at the build level, then that
version takes precedence over this sourceVersion (at the project level). For more
information, see Source Version Sample with CodeBuild in the CodeBuild User Guide.
- `"tags"`: A list of tag key and value pairs associated with this build project. These
tags are available for use by Amazon Web Services services that support CodeBuild build
project tags.
- `"timeoutInMinutes"`: How long, in minutes, from 5 to 2160 (36 hours), for CodeBuild to
wait before it times out any build that has not been marked as completed. The default is 60
minutes.
- `"vpcConfig"`: VpcConfig enables CodeBuild to access resources in an Amazon VPC. If
you're using compute fleets during project creation, do not provide vpcConfig.
"""
function create_project(
artifacts,
environment,
name,
serviceRole,
source;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateProject",
Dict{String,Any}(
"artifacts" => artifacts,
"environment" => environment,
"name" => name,
"serviceRole" => serviceRole,
"source" => source,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_project(
artifacts,
environment,
name,
serviceRole,
source,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateProject",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"artifacts" => artifacts,
"environment" => environment,
"name" => name,
"serviceRole" => serviceRole,
"source" => source,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_report_group(export_config, name, type)
create_report_group(export_config, name, type, params::Dict{String,<:Any})
Creates a report group. A report group contains a collection of reports.
# Arguments
- `export_config`: A ReportExportConfig object that contains information about where the
report group test results are exported.
- `name`: The name of the report group.
- `type`: The type of report group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: A list of tag key and value pairs associated with this report group. These
tags are available for use by Amazon Web Services services that support CodeBuild report
group tags.
"""
function create_report_group(
exportConfig, name, type; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"CreateReportGroup",
Dict{String,Any}("exportConfig" => exportConfig, "name" => name, "type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_report_group(
exportConfig,
name,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateReportGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"exportConfig" => exportConfig, "name" => name, "type" => type
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_webhook(project_name)
create_webhook(project_name, params::Dict{String,<:Any})
For an existing CodeBuild build project that has its source code stored in a GitHub or
Bitbucket repository, enables CodeBuild to start rebuilding the source code every time a
code change is pushed to the repository. If you enable webhooks for an CodeBuild project,
and the project is used as a build step in CodePipeline, then two identical builds are
created for each commit. One build is triggered through webhooks, and one through
CodePipeline. Because billing is on a per-build basis, you are billed for both builds.
Therefore, if you are using CodePipeline, we recommend that you disable webhooks in
CodeBuild. In the CodeBuild console, clear the Webhook box. For more information, see step
5 in Change a Build Project's Settings.
# Arguments
- `project_name`: The name of the CodeBuild project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"branchFilter"`: A regular expression used to determine which repository branches are
built when a webhook is triggered. If the name of a branch matches the regular expression,
then it is built. If branchFilter is empty, then all branches are built. It is recommended
that you use filterGroups instead of branchFilter.
- `"buildType"`: Specifies the type of build this webhook will trigger.
- `"filterGroups"`: An array of arrays of WebhookFilter objects used to determine which
webhooks are triggered. At least one WebhookFilter in the array must specify EVENT as its
type. For a build to be triggered, at least one filter group in the filterGroups array
must pass. For a filter group to pass, each of its filters must pass.
- `"manualCreation"`: If manualCreation is true, CodeBuild doesn't create a webhook in
GitHub and instead returns payloadUrl and secret values for the webhook. The payloadUrl and
secret values in the output can be used to manually create a webhook within GitHub.
manualCreation is only available for GitHub webhooks.
- `"scopeConfiguration"`: The scope configuration for global or organization webhooks.
Global or organization webhooks are only available for GitHub and Github Enterprise
webhooks.
"""
function create_webhook(projectName; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"CreateWebhook",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_webhook(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"CreateWebhook",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_build_batch(id)
delete_build_batch(id, params::Dict{String,<:Any})
Deletes a batch build.
# Arguments
- `id`: The identifier of the batch build to delete.
"""
function delete_build_batch(id; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteBuildBatch",
Dict{String,Any}("id" => id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_build_batch(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteBuildBatch",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("id" => id), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_fleet(arn)
delete_fleet(arn, params::Dict{String,<:Any})
Deletes a compute fleet. When you delete a compute fleet, its builds are not deleted.
# Arguments
- `arn`: The ARN of the compute fleet.
"""
function delete_fleet(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteFleet",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_fleet(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteFleet",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_project(name)
delete_project(name, params::Dict{String,<:Any})
Deletes a build project. When you delete a project, its builds are not deleted.
# Arguments
- `name`: The name of the build project.
"""
function delete_project(name; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteProject",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_project(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteProject",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_report(arn)
delete_report(arn, params::Dict{String,<:Any})
Deletes a report.
# Arguments
- `arn`: The ARN of the report to delete.
"""
function delete_report(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteReport",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_report(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteReport",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_report_group(arn)
delete_report_group(arn, params::Dict{String,<:Any})
Deletes a report group. Before you delete a report group, you must delete its reports.
# Arguments
- `arn`: The ARN of the report group to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deleteReports"`: If true, deletes any reports that belong to a report group before
deleting the report group. If false, you must delete any reports in the report group. Use
ListReportsForReportGroup to get the reports in a report group. Use DeleteReport to delete
the reports. If you call DeleteReportGroup for a report group that contains one or more
reports, an exception is thrown.
"""
function delete_report_group(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteReportGroup",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_report_group(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteReportGroup",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resource_policy(resource_arn)
delete_resource_policy(resource_arn, params::Dict{String,<:Any})
Deletes a resource policy that is identified by its resource ARN.
# Arguments
- `resource_arn`: The ARN of the resource that is associated with the resource policy.
"""
function delete_resource_policy(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteResourcePolicy",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resource_policy(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"DeleteResourcePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_source_credentials(arn)
delete_source_credentials(arn, params::Dict{String,<:Any})
Deletes a set of GitHub, GitHub Enterprise, or Bitbucket source credentials.
# Arguments
- `arn`: The Amazon Resource Name (ARN) of the token.
"""
function delete_source_credentials(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteSourceCredentials",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_source_credentials(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DeleteSourceCredentials",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_webhook(project_name)
delete_webhook(project_name, params::Dict{String,<:Any})
For an existing CodeBuild build project that has its source code stored in a GitHub or
Bitbucket repository, stops CodeBuild from rebuilding the source code every time a code
change is pushed to the repository.
# Arguments
- `project_name`: The name of the CodeBuild project.
"""
function delete_webhook(projectName; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DeleteWebhook",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_webhook(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"DeleteWebhook",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_code_coverages(report_arn)
describe_code_coverages(report_arn, params::Dict{String,<:Any})
Retrieves one or more code coverage reports.
# Arguments
- `report_arn`: The ARN of the report for which test cases are returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxLineCoveragePercentage"`: The maximum line coverage percentage to report.
- `"maxResults"`: The maximum number of results to return.
- `"minLineCoveragePercentage"`: The minimum line coverage percentage to report.
- `"nextToken"`: The nextToken value returned from a previous call to
DescribeCodeCoverages. This specifies the next item to return. To return the beginning of
the list, exclude this parameter.
- `"sortBy"`: Specifies how the results are sorted. Possible values are: FILE_PATH The
results are sorted by file path. LINE_COVERAGE_PERCENTAGE The results are sorted by the
percentage of lines that are covered.
- `"sortOrder"`: Specifies if the results are sorted in ascending or descending order.
"""
function describe_code_coverages(
reportArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"DescribeCodeCoverages",
Dict{String,Any}("reportArn" => reportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_code_coverages(
reportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"DescribeCodeCoverages",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportArn" => reportArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_test_cases(report_arn)
describe_test_cases(report_arn, params::Dict{String,<:Any})
Returns a list of details about test cases for a report.
# Arguments
- `report_arn`: The ARN of the report for which test cases are returned.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A TestCaseFilter object used to filter the returned reports.
- `"maxResults"`: The maximum number of paginated test cases returned per response. Use
nextToken to iterate pages in the list of returned TestCase objects. The default value is
100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
"""
function describe_test_cases(reportArn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"DescribeTestCases",
Dict{String,Any}("reportArn" => reportArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_test_cases(
reportArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"DescribeTestCases",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportArn" => reportArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_report_group_trend(report_group_arn, trend_field)
get_report_group_trend(report_group_arn, trend_field, params::Dict{String,<:Any})
Analyzes and accumulates test report values for the specified test reports.
# Arguments
- `report_group_arn`: The ARN of the report group that contains the reports to analyze.
- `trend_field`: The test report value to accumulate. This must be one of the following
values: Test reports: DURATION Accumulate the test run times for the specified reports.
PASS_RATE Accumulate the percentage of tests that passed for the specified test reports.
TOTAL Accumulate the total number of tests for the specified test reports. Code
coverage reports: BRANCH_COVERAGE Accumulate the branch coverage percentages for the
specified test reports. BRANCHES_COVERED Accumulate the branches covered values for the
specified test reports. BRANCHES_MISSED Accumulate the branches missed values for the
specified test reports. LINE_COVERAGE Accumulate the line coverage percentages for the
specified test reports. LINES_COVERED Accumulate the lines covered values for the
specified test reports. LINES_MISSED Accumulate the lines not covered values for the
specified test reports.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"numOfReports"`: The number of reports to analyze. This operation always retrieves the
most recent reports. If this parameter is omitted, the most recent 100 reports are analyzed.
"""
function get_report_group_trend(
reportGroupArn, trendField; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"GetReportGroupTrend",
Dict{String,Any}("reportGroupArn" => reportGroupArn, "trendField" => trendField);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_report_group_trend(
reportGroupArn,
trendField,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"GetReportGroupTrend",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"reportGroupArn" => reportGroupArn, "trendField" => trendField
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource_policy(resource_arn)
get_resource_policy(resource_arn, params::Dict{String,<:Any})
Gets a resource policy that is identified by its resource ARN.
# Arguments
- `resource_arn`: The ARN of the resource that is associated with the resource policy.
"""
function get_resource_policy(resourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"GetResourcePolicy",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource_policy(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"GetResourcePolicy",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
import_source_credentials(auth_type, server_type, token)
import_source_credentials(auth_type, server_type, token, params::Dict{String,<:Any})
Imports the source repository credentials for an CodeBuild project that has its source
code stored in a GitHub, GitHub Enterprise, or Bitbucket repository.
# Arguments
- `auth_type`: The type of authentication used to connect to a GitHub, GitHub Enterprise,
GitLab, GitLab Self Managed, or Bitbucket repository. An OAUTH connection is not supported
by the API and must be created using the CodeBuild console. Note that CODECONNECTIONS is
only valid for GitLab and GitLab Self Managed.
- `server_type`: The source provider used for this project.
- `token`: For GitHub or GitHub Enterprise, this is the personal access token. For
Bitbucket, this is either the access token or the app password. For the authType
CODECONNECTIONS, this is the connectionArn.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"shouldOverwrite"`: Set to false to prevent overwriting the repository source
credentials. Set to true to overwrite the repository source credentials. The default value
is true.
- `"username"`: The Bitbucket username when the authType is BASIC_AUTH. This parameter is
not valid for other types of source providers or connections.
"""
function import_source_credentials(
authType, serverType, token; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ImportSourceCredentials",
Dict{String,Any}(
"authType" => authType, "serverType" => serverType, "token" => token
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function import_source_credentials(
authType,
serverType,
token,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"ImportSourceCredentials",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"authType" => authType, "serverType" => serverType, "token" => token
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
invalidate_project_cache(project_name)
invalidate_project_cache(project_name, params::Dict{String,<:Any})
Resets the cache for a project.
# Arguments
- `project_name`: The name of the CodeBuild build project that the cache is reset for.
"""
function invalidate_project_cache(
projectName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"InvalidateProjectCache",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function invalidate_project_cache(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"InvalidateProjectCache",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_build_batches()
list_build_batches(params::Dict{String,<:Any})
Retrieves the identifiers of your build batches in the current region.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A BuildBatchFilter object that specifies the filters for the search.
- `"maxResults"`: The maximum number of results to return.
- `"nextToken"`: The nextToken value returned from a previous call to ListBuildBatches.
This specifies the next item to return. To return the beginning of the list, exclude this
parameter.
- `"sortOrder"`: Specifies the sort order of the returned items. Valid values include:
ASCENDING: List the batch build identifiers in ascending order by identifier.
DESCENDING: List the batch build identifiers in descending order by identifier.
"""
function list_build_batches(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListBuildBatches"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_build_batches(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListBuildBatches", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_build_batches_for_project()
list_build_batches_for_project(params::Dict{String,<:Any})
Retrieves the identifiers of the build batches for a specific project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A BuildBatchFilter object that specifies the filters for the search.
- `"maxResults"`: The maximum number of results to return.
- `"nextToken"`: The nextToken value returned from a previous call to
ListBuildBatchesForProject. This specifies the next item to return. To return the beginning
of the list, exclude this parameter.
- `"projectName"`: The name of the project.
- `"sortOrder"`: Specifies the sort order of the returned items. Valid values include:
ASCENDING: List the batch build identifiers in ascending order by identifier.
DESCENDING: List the batch build identifiers in descending order by identifier.
"""
function list_build_batches_for_project(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListBuildBatchesForProject"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_build_batches_for_project(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListBuildBatchesForProject",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_builds()
list_builds(params::Dict{String,<:Any})
Gets a list of build IDs, with each build ID representing a single build.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: During a previous call, if there are more than 100 items in the list, only
the first 100 items are returned, along with a unique string called a nextToken. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
- `"sortOrder"`: The order to list build IDs. Valid values include: ASCENDING: List the
build IDs in ascending order by build ID. DESCENDING: List the build IDs in descending
order by build ID.
"""
function list_builds(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild("ListBuilds"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_builds(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListBuilds", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_builds_for_project(project_name)
list_builds_for_project(project_name, params::Dict{String,<:Any})
Gets a list of build identifiers for the specified build project, with each build
identifier representing a single build.
# Arguments
- `project_name`: The name of the CodeBuild project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: During a previous call, if there are more than 100 items in the list, only
the first 100 items are returned, along with a unique string called a nextToken. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
- `"sortOrder"`: The order to sort the results in. The results are sorted by build number,
not the build identifier. If this is not specified, the results are sorted in descending
order. Valid values include: ASCENDING: List the build identifiers in ascending order,
by build number. DESCENDING: List the build identifiers in descending order, by build
number. If the project has more than 100 builds, setting the sort order will result in an
error.
"""
function list_builds_for_project(
projectName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListBuildsForProject",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_builds_for_project(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"ListBuildsForProject",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_curated_environment_images()
list_curated_environment_images(params::Dict{String,<:Any})
Gets information about Docker images that are managed by CodeBuild.
"""
function list_curated_environment_images(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListCuratedEnvironmentImages";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_curated_environment_images(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListCuratedEnvironmentImages",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_fleets()
list_fleets(params::Dict{String,<:Any})
Gets a list of compute fleet names with each compute fleet name representing a single
compute fleet.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of paginated compute fleets returned per response. Use
nextToken to iterate pages in the list of returned compute fleets.
- `"nextToken"`: During a previous call, if there are more than 100 items in the list, only
the first 100 items are returned, along with a unique string called a nextToken. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
- `"sortBy"`: The criterion to be used to list compute fleet names. Valid values include:
CREATED_TIME: List based on when each compute fleet was created. LAST_MODIFIED_TIME:
List based on when information about each compute fleet was last changed. NAME: List
based on each compute fleet's name. Use sortOrder to specify in what order to list the
compute fleet names based on the preceding criteria.
- `"sortOrder"`: The order in which to list compute fleets. Valid values include:
ASCENDING: List in ascending order. DESCENDING: List in descending order. Use sortBy
to specify the criterion to be used to list compute fleet names.
"""
function list_fleets(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild("ListFleets"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_fleets(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListFleets", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_projects()
list_projects(params::Dict{String,<:Any})
Gets a list of build project names, with each build project name representing a single
build project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: During a previous call, if there are more than 100 items in the list, only
the first 100 items are returned, along with a unique string called a nextToken. To get the
next batch of items in the list, call this operation again, adding the next token to the
call. To get all of the items in the list, keep calling this operation with each subsequent
next token that is returned, until no more next tokens are returned.
- `"sortBy"`: The criterion to be used to list build project names. Valid values include:
CREATED_TIME: List based on when each build project was created. LAST_MODIFIED_TIME:
List based on when information about each build project was last changed. NAME: List
based on each build project's name. Use sortOrder to specify in what order to list the
build project names based on the preceding criteria.
- `"sortOrder"`: The order in which to list build projects. Valid values include:
ASCENDING: List in ascending order. DESCENDING: List in descending order. Use sortBy
to specify the criterion to be used to list build project names.
"""
function list_projects(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild("ListProjects"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_projects(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListProjects", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_report_groups()
list_report_groups(params::Dict{String,<:Any})
Gets a list ARNs for the report groups in the current Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of paginated report groups returned per response. Use
nextToken to iterate pages in the list of returned ReportGroup objects. The default value
is 100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
- `"sortBy"`: The criterion to be used to list build report groups. Valid values include:
CREATED_TIME: List based on when each report group was created. LAST_MODIFIED_TIME:
List based on when each report group was last changed. NAME: List based on each report
group's name.
- `"sortOrder"`: Used to specify the order to sort the list of returned report groups.
Valid values are ASCENDING and DESCENDING.
"""
function list_report_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListReportGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_report_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListReportGroups", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_reports()
list_reports(params::Dict{String,<:Any})
Returns a list of ARNs for the reports in the current Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A ReportFilter object used to filter the returned reports.
- `"maxResults"`: The maximum number of paginated reports returned per response. Use
nextToken to iterate pages in the list of returned Report objects. The default value is
100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
- `"sortOrder"`: Specifies the sort order for the list of returned reports. Valid values
are: ASCENDING: return reports in chronological order based on their creation date.
DESCENDING: return reports in the reverse chronological order based on their creation date.
"""
function list_reports(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild("ListReports"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function list_reports(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListReports", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_reports_for_report_group(report_group_arn)
list_reports_for_report_group(report_group_arn, params::Dict{String,<:Any})
Returns a list of ARNs for the reports that belong to a ReportGroup.
# Arguments
- `report_group_arn`: The ARN of the report group for which you want to return report
ARNs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: A ReportFilter object used to filter the returned reports.
- `"maxResults"`: The maximum number of paginated reports in this report group returned
per response. Use nextToken to iterate pages in the list of returned Report objects. The
default value is 100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
- `"sortOrder"`: Use to specify whether the results are returned in ascending or
descending order.
"""
function list_reports_for_report_group(
reportGroupArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListReportsForReportGroup",
Dict{String,Any}("reportGroupArn" => reportGroupArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_reports_for_report_group(
reportGroupArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"ListReportsForReportGroup",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("reportGroupArn" => reportGroupArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_shared_projects()
list_shared_projects(params::Dict{String,<:Any})
Gets a list of projects that are shared with other Amazon Web Services accounts or users.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of paginated shared build projects returned per
response. Use nextToken to iterate pages in the list of returned Project objects. The
default value is 100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
- `"sortBy"`: The criterion to be used to list build projects shared with the current
Amazon Web Services account or user. Valid values include: ARN: List based on the ARN.
MODIFIED_TIME: List based on when information about the shared project was last changed.
- `"sortOrder"`: The order in which to list shared build projects. Valid values include:
ASCENDING: List in ascending order. DESCENDING: List in descending order.
"""
function list_shared_projects(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListSharedProjects"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_shared_projects(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListSharedProjects", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_shared_report_groups()
list_shared_report_groups(params::Dict{String,<:Any})
Gets a list of report groups that are shared with other Amazon Web Services accounts or
users.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of paginated shared report groups per response. Use
nextToken to iterate pages in the list of returned ReportGroup objects. The default value
is 100.
- `"nextToken"`: During a previous call, the maximum number of items that can be returned
is the value specified in maxResults. If there more items in the list, then a unique string
called a nextToken is returned. To get the next batch of items in the list, call this
operation again, adding the next token to the call. To get all of the items in the list,
keep calling this operation with each subsequent next token that is returned, until no more
next tokens are returned.
- `"sortBy"`: The criterion to be used to list report groups shared with the current
Amazon Web Services account or user. Valid values include: ARN: List based on the ARN.
MODIFIED_TIME: List based on when information about the shared report group was last
changed.
- `"sortOrder"`: The order in which to list shared report groups. Valid values include:
ASCENDING: List in ascending order. DESCENDING: List in descending order.
"""
function list_shared_report_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListSharedReportGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_shared_report_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListSharedReportGroups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_source_credentials()
list_source_credentials(params::Dict{String,<:Any})
Returns a list of SourceCredentialsInfo objects.
"""
function list_source_credentials(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"ListSourceCredentials"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_source_credentials(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"ListSourceCredentials",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_resource_policy(policy, resource_arn)
put_resource_policy(policy, resource_arn, params::Dict{String,<:Any})
Stores a resource policy for the ARN of a Project or ReportGroup object.
# Arguments
- `policy`: A JSON-formatted resource policy. For more information, see Sharing a Project
and Sharing a Report Group in the CodeBuild User Guide.
- `resource_arn`: The ARN of the Project or ReportGroup resource you want to associate
with a resource policy.
"""
function put_resource_policy(
policy, resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"PutResourcePolicy",
Dict{String,Any}("policy" => policy, "resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_resource_policy(
policy,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"PutResourcePolicy",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("policy" => policy, "resourceArn" => resourceArn),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
retry_build()
retry_build(params::Dict{String,<:Any})
Restarts a build.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"id"`: Specifies the identifier of the build to restart.
- `"idempotencyToken"`: A unique, case sensitive identifier you provide to ensure the
idempotency of the RetryBuild request. The token is included in the RetryBuild request and
is valid for five minutes. If you repeat the RetryBuild request with the same token, but
change a parameter, CodeBuild returns a parameter mismatch error.
"""
function retry_build(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild("RetryBuild"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function retry_build(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"RetryBuild", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
retry_build_batch()
retry_build_batch(params::Dict{String,<:Any})
Restarts a failed batch build. Only batch builds that have failed can be retried.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"id"`: Specifies the identifier of the batch build to restart.
- `"idempotencyToken"`: A unique, case sensitive identifier you provide to ensure the
idempotency of the RetryBuildBatch request. The token is included in the RetryBuildBatch
request and is valid for five minutes. If you repeat the RetryBuildBatch request with the
same token, but change a parameter, CodeBuild returns a parameter mismatch error.
- `"retryType"`: Specifies the type of retry to perform.
"""
function retry_build_batch(; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"RetryBuildBatch"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function retry_build_batch(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"RetryBuildBatch", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
start_build(project_name)
start_build(project_name, params::Dict{String,<:Any})
Starts running a build with the settings defined in the project. These setting include: how
to run a build, where to get the source code, which build environment to use, which build
commands to run, and where to store the build output. You can also start a build run by
overriding some of the build settings in the project. The overrides only apply for that
specific start build request. The settings in the project are unaltered.
# Arguments
- `project_name`: The name of the CodeBuild build project to start running a build.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"artifactsOverride"`: Build output artifact settings that override, for this build only,
the latest ones already defined in the build project.
- `"buildStatusConfigOverride"`: Contains information that defines how the build project
reports the build status to the source provider. This option is only used when the source
provider is GITHUB, GITHUB_ENTERPRISE, or BITBUCKET.
- `"buildspecOverride"`: A buildspec file declaration that overrides the latest one defined
in the build project, for this build only. The buildspec defined on the project is not
changed. If this value is set, it can be either an inline buildspec definition, the path to
an alternate buildspec file relative to the value of the built-in CODEBUILD_SRC_DIR
environment variable, or the path to an S3 bucket. The bucket must be in the same Amazon
Web Services Region as the build project. Specify the buildspec file using its ARN (for
example, arn:aws:s3:::my-codebuild-sample2/buildspec.yml). If this value is not provided or
is set to an empty string, the source code must contain a buildspec file in its root
directory. For more information, see Buildspec File Name and Storage Location. Since this
property allows you to change the build commands that will run in the container, you should
note that an IAM principal with the ability to call this API and set this parameter can
override the default settings. Moreover, we encourage that you use a trustworthy buildspec
location like a file in your source repository or a Amazon S3 bucket.
- `"cacheOverride"`: A ProjectCache object specified for this build that overrides the one
defined in the build project.
- `"certificateOverride"`: The name of a certificate for this build that overrides the one
specified in the build project.
- `"computeTypeOverride"`: The name of a compute type for this build that overrides the one
specified in the build project.
- `"debugSessionEnabled"`: Specifies if session debugging is enabled for this build. For
more information, see Viewing a running build in Session Manager.
- `"encryptionKeyOverride"`: The Key Management Service customer master key (CMK) that
overrides the one specified in the build project. The CMK key encrypts the build output
artifacts. You can use a cross-account KMS key to encrypt the build output artifacts if
your service role has permission to that key. You can specify either the Amazon Resource
Name (ARN) of the CMK or, if available, the CMK's alias (using the format
alias/<alias-name>).
- `"environmentTypeOverride"`: A container type for this build that overrides the one
specified in the build project.
- `"environmentVariablesOverride"`: A set of environment variables that overrides, for this
build only, the latest ones already defined in the build project.
- `"fleetOverride"`: A ProjectFleet object specified for this build that overrides the one
defined in the build project.
- `"gitCloneDepthOverride"`: The user-defined depth of history, with a minimum value of 0,
that overrides, for this build only, any previous depth of history defined in the build
project.
- `"gitSubmodulesConfigOverride"`: Information about the Git submodules configuration for
this build of an CodeBuild build project.
- `"idempotencyToken"`: A unique, case sensitive identifier you provide to ensure the
idempotency of the StartBuild request. The token is included in the StartBuild request and
is valid for 5 minutes. If you repeat the StartBuild request with the same token, but
change a parameter, CodeBuild returns a parameter mismatch error.
- `"imageOverride"`: The name of an image for this build that overrides the one specified
in the build project.
- `"imagePullCredentialsTypeOverride"`: The type of credentials CodeBuild uses to pull
images in your build. There are two valid values: CODEBUILD Specifies that CodeBuild
uses its own credentials. This requires that you modify your ECR repository policy to trust
CodeBuild's service principal. SERVICE_ROLE Specifies that CodeBuild uses your build
project's service role. When using a cross-account or private registry image, you must
use SERVICE_ROLE credentials. When using an CodeBuild curated image, you must use CODEBUILD
credentials.
- `"insecureSslOverride"`: Enable this flag to override the insecure SSL setting that is
specified in the build project. The insecure SSL setting determines whether to ignore SSL
warnings while connecting to the project source code. This override applies only if the
build's source is GitHub Enterprise.
- `"logsConfigOverride"`: Log settings for this build that override the log settings
defined in the build project.
- `"privilegedModeOverride"`: Enable this flag to override privileged mode in the build
project.
- `"queuedTimeoutInMinutesOverride"`: The number of minutes a build is allowed to be
queued before it times out.
- `"registryCredentialOverride"`: The credentials for access to a private registry.
- `"reportBuildStatusOverride"`: Set to true to report to your source provider the status
of a build's start and completion. If you use this option with a source provider other than
GitHub, GitHub Enterprise, or Bitbucket, an invalidInputException is thrown. To be able to
report the build status to the source provider, the user associated with the source
provider must have write access to the repo. If the user does not have write access, the
build status cannot be updated. For more information, see Source provider access in the
CodeBuild User Guide. The status of a build triggered by a webhook is always reported to
your source provider.
- `"secondaryArtifactsOverride"`: An array of ProjectArtifacts objects.
- `"secondarySourcesOverride"`: An array of ProjectSource objects.
- `"secondarySourcesVersionOverride"`: An array of ProjectSourceVersion objects that
specify one or more versions of the project's secondary sources to be used for this build
only.
- `"serviceRoleOverride"`: The name of a service role for this build that overrides the one
specified in the build project.
- `"sourceAuthOverride"`: An authorization type for this build that overrides the one
defined in the build project. This override applies only if the build project's source is
BitBucket, GitHub, GitLab, or GitLab Self Managed.
- `"sourceLocationOverride"`: A location that overrides, for this build, the source
location for the one defined in the build project.
- `"sourceTypeOverride"`: A source input type, for this build, that overrides the source
input defined in the build project.
- `"sourceVersion"`: The version of the build input to be built, for this build only. If
not specified, the latest version is used. If specified, the contents depends on the source
provider: CodeCommit The commit ID, branch, or Git tag to use. GitHub The commit ID,
pull request ID, branch name, or tag name that corresponds to the version of the source
code you want to build. If a pull request ID is specified, it must use the format
pr/pull-request-ID (for example pr/25). If a branch name is specified, the branch's HEAD
commit ID is used. If not specified, the default branch's HEAD commit ID is used. GitLab
The commit ID, branch, or Git tag to use. Bitbucket The commit ID, branch name, or tag
name that corresponds to the version of the source code you want to build. If a branch name
is specified, the branch's HEAD commit ID is used. If not specified, the default branch's
HEAD commit ID is used. Amazon S3 The version ID of the object that represents the build
input ZIP file to use. If sourceVersion is specified at the project level, then this
sourceVersion (at the build level) takes precedence. For more information, see Source
Version Sample with CodeBuild in the CodeBuild User Guide.
- `"timeoutInMinutesOverride"`: The number of build timeout minutes, from 5 to 2160 (36
hours), that overrides, for this build only, the latest setting already defined in the
build project.
"""
function start_build(projectName; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"StartBuild",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_build(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"StartBuild",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_build_batch(project_name)
start_build_batch(project_name, params::Dict{String,<:Any})
Starts a batch build for a project.
# Arguments
- `project_name`: The name of the project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"artifactsOverride"`: An array of ProjectArtifacts objects that contains information
about the build output artifact overrides for the build project.
- `"buildBatchConfigOverride"`: A BuildBatchConfigOverride object that contains batch build
configuration overrides.
- `"buildTimeoutInMinutesOverride"`: Overrides the build timeout specified in the batch
build project.
- `"buildspecOverride"`: A buildspec file declaration that overrides, for this build only,
the latest one already defined in the build project. If this value is set, it can be either
an inline buildspec definition, the path to an alternate buildspec file relative to the
value of the built-in CODEBUILD_SRC_DIR environment variable, or the path to an S3 bucket.
The bucket must be in the same Amazon Web Services Region as the build project. Specify the
buildspec file using its ARN (for example,
arn:aws:s3:::my-codebuild-sample2/buildspec.yml). If this value is not provided or is set
to an empty string, the source code must contain a buildspec file in its root directory.
For more information, see Buildspec File Name and Storage Location.
- `"cacheOverride"`: A ProjectCache object that specifies cache overrides.
- `"certificateOverride"`: The name of a certificate for this batch build that overrides
the one specified in the batch build project.
- `"computeTypeOverride"`: The name of a compute type for this batch build that overrides
the one specified in the batch build project.
- `"debugSessionEnabled"`: Specifies if session debugging is enabled for this batch build.
For more information, see Viewing a running build in Session Manager. Batch session
debugging is not supported for matrix batch builds.
- `"encryptionKeyOverride"`: The Key Management Service customer master key (CMK) that
overrides the one specified in the batch build project. The CMK key encrypts the build
output artifacts. You can use a cross-account KMS key to encrypt the build output
artifacts if your service role has permission to that key. You can specify either the
Amazon Resource Name (ARN) of the CMK or, if available, the CMK's alias (using the format
alias/<alias-name>).
- `"environmentTypeOverride"`: A container type for this batch build that overrides the one
specified in the batch build project.
- `"environmentVariablesOverride"`: An array of EnvironmentVariable objects that override,
or add to, the environment variables defined in the batch build project.
- `"gitCloneDepthOverride"`: The user-defined depth of history, with a minimum value of 0,
that overrides, for this batch build only, any previous depth of history defined in the
batch build project.
- `"gitSubmodulesConfigOverride"`: A GitSubmodulesConfig object that overrides the Git
submodules configuration for this batch build.
- `"idempotencyToken"`: A unique, case sensitive identifier you provide to ensure the
idempotency of the StartBuildBatch request. The token is included in the StartBuildBatch
request and is valid for five minutes. If you repeat the StartBuildBatch request with the
same token, but change a parameter, CodeBuild returns a parameter mismatch error.
- `"imageOverride"`: The name of an image for this batch build that overrides the one
specified in the batch build project.
- `"imagePullCredentialsTypeOverride"`: The type of credentials CodeBuild uses to pull
images in your batch build. There are two valid values: CODEBUILD Specifies that
CodeBuild uses its own credentials. This requires that you modify your ECR repository
policy to trust CodeBuild's service principal. SERVICE_ROLE Specifies that CodeBuild uses
your build project's service role. When using a cross-account or private registry image,
you must use SERVICE_ROLE credentials. When using an CodeBuild curated image, you must use
CODEBUILD credentials.
- `"insecureSslOverride"`: Enable this flag to override the insecure SSL setting that is
specified in the batch build project. The insecure SSL setting determines whether to ignore
SSL warnings while connecting to the project source code. This override applies only if the
build's source is GitHub Enterprise.
- `"logsConfigOverride"`: A LogsConfig object that override the log settings defined in the
batch build project.
- `"privilegedModeOverride"`: Enable this flag to override privileged mode in the batch
build project.
- `"queuedTimeoutInMinutesOverride"`: The number of minutes a batch build is allowed to be
queued before it times out.
- `"registryCredentialOverride"`: A RegistryCredential object that overrides credentials
for access to a private registry.
- `"reportBuildBatchStatusOverride"`: Set to true to report to your source provider the
status of a batch build's start and completion. If you use this option with a source
provider other than GitHub, GitHub Enterprise, or Bitbucket, an invalidInputException is
thrown. The status of a build triggered by a webhook is always reported to your source
provider.
- `"secondaryArtifactsOverride"`: An array of ProjectArtifacts objects that override the
secondary artifacts defined in the batch build project.
- `"secondarySourcesOverride"`: An array of ProjectSource objects that override the
secondary sources defined in the batch build project.
- `"secondarySourcesVersionOverride"`: An array of ProjectSourceVersion objects that
override the secondary source versions in the batch build project.
- `"serviceRoleOverride"`: The name of a service role for this batch build that overrides
the one specified in the batch build project.
- `"sourceAuthOverride"`: A SourceAuth object that overrides the one defined in the batch
build project. This override applies only if the build project's source is BitBucket or
GitHub.
- `"sourceLocationOverride"`: A location that overrides, for this batch build, the source
location defined in the batch build project.
- `"sourceTypeOverride"`: The source input type that overrides the source input defined in
the batch build project.
- `"sourceVersion"`: The version of the batch build input to be built, for this build only.
If not specified, the latest version is used. If specified, the contents depends on the
source provider: CodeCommit The commit ID, branch, or Git tag to use. GitHub The commit
ID, pull request ID, branch name, or tag name that corresponds to the version of the source
code you want to build. If a pull request ID is specified, it must use the format
pr/pull-request-ID (for example pr/25). If a branch name is specified, the branch's HEAD
commit ID is used. If not specified, the default branch's HEAD commit ID is used.
Bitbucket The commit ID, branch name, or tag name that corresponds to the version of the
source code you want to build. If a branch name is specified, the branch's HEAD commit ID
is used. If not specified, the default branch's HEAD commit ID is used. Amazon S3 The
version ID of the object that represents the build input ZIP file to use. If
sourceVersion is specified at the project level, then this sourceVersion (at the build
level) takes precedence. For more information, see Source Version Sample with CodeBuild in
the CodeBuild User Guide.
"""
function start_build_batch(projectName; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"StartBuildBatch",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_build_batch(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"StartBuildBatch",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_build(id)
stop_build(id, params::Dict{String,<:Any})
Attempts to stop running a build.
# Arguments
- `id`: The ID of the build.
"""
function stop_build(id; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"StopBuild",
Dict{String,Any}("id" => id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_build(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"StopBuild",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("id" => id), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_build_batch(id)
stop_build_batch(id, params::Dict{String,<:Any})
Stops a running batch build.
# Arguments
- `id`: The identifier of the batch build to stop.
"""
function stop_build_batch(id; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"StopBuildBatch",
Dict{String,Any}("id" => id);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_build_batch(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"StopBuildBatch",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("id" => id), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_fleet(arn)
update_fleet(arn, params::Dict{String,<:Any})
Updates a compute fleet.
# Arguments
- `arn`: The ARN of the compute fleet.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"baseCapacity"`: The initial number of machines allocated to the compute fleet, which
defines the number of builds that can run in parallel.
- `"computeType"`: Information about the compute resources the compute fleet uses.
Available values include: BUILD_GENERAL1_SMALL: Use up to 3 GB memory and 2 vCPUs for
builds. BUILD_GENERAL1_MEDIUM: Use up to 7 GB memory and 4 vCPUs for builds.
BUILD_GENERAL1_LARGE: Use up to 16 GB memory and 8 vCPUs for builds, depending on your
environment type. BUILD_GENERAL1_XLARGE: Use up to 70 GB memory and 36 vCPUs for builds,
depending on your environment type. BUILD_GENERAL1_2XLARGE: Use up to 145 GB memory, 72
vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to
100 GB uncompressed. If you use BUILD_GENERAL1_SMALL: For environment type
LINUX_CONTAINER, you can use up to 3 GB memory and 2 vCPUs for builds. For environment
type LINUX_GPU_CONTAINER, you can use up to 16 GB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor
Core GPU for builds. For environment type ARM_CONTAINER, you can use up to 4 GB memory
and 2 vCPUs on ARM-based processors for builds. If you use BUILD_GENERAL1_LARGE: For
environment type LINUX_CONTAINER, you can use up to 15 GB memory and 8 vCPUs for builds.
For environment type LINUX_GPU_CONTAINER, you can use up to 255 GB memory, 32 vCPUs, and 4
NVIDIA Tesla V100 GPUs for builds. For environment type ARM_CONTAINER, you can use up to
16 GB memory and 8 vCPUs on ARM-based processors for builds. For more information, see
Build environment compute types in the CodeBuild User Guide.
- `"environmentType"`: The environment type of the compute fleet. The environment type
ARM_CONTAINER is available only in regions US East (N. Virginia), US East (Ohio), US West
(Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific
(Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). The
environment type LINUX_CONTAINER is available only in regions US East (N. Virginia), US
East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia
Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific
(Mumbai). The environment type LINUX_GPU_CONTAINER is available only in regions US East
(N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
(Tokyo), and Asia Pacific (Sydney). The environment type WINDOWS_SERVER_2019_CONTAINER is
available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia
Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). The
environment type WINDOWS_SERVER_2022_CONTAINER is available only in regions US East (N.
Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific
(Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and
Asia Pacific (Mumbai). For more information, see Build environment compute types in the
CodeBuild user guide.
- `"fleetServiceRole"`: The service role associated with the compute fleet. For more
information, see Allow a user to add a permission policy for a fleet service role in the
CodeBuild User Guide.
- `"overflowBehavior"`: The compute fleet overflow behavior. For overflow behavior QUEUE,
your overflow builds need to wait on the existing fleet instance to become available. For
overflow behavior ON_DEMAND, your overflow builds run on CodeBuild on-demand. If you
choose to set your overflow behavior to on-demand while creating a VPC-connected fleet,
make sure that you add the required VPC permissions to your project service role. For more
information, see Example policy statement to allow CodeBuild access to Amazon Web Services
services required to create a VPC network interface.
- `"scalingConfiguration"`: The scaling configuration of the compute fleet.
- `"tags"`: A list of tag key and value pairs associated with this compute fleet. These
tags are available for use by Amazon Web Services services that support CodeBuild build
project tags.
- `"vpcConfig"`:
"""
function update_fleet(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"UpdateFleet",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_fleet(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"UpdateFleet",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_project(name)
update_project(name, params::Dict{String,<:Any})
Changes the settings of a build project.
# Arguments
- `name`: The name of the build project. You cannot change a build project's name.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"artifacts"`: Information to be changed about the build output artifacts for the build
project.
- `"badgeEnabled"`: Set this to true to generate a publicly accessible URL for your
project's build badge.
- `"buildBatchConfig"`:
- `"cache"`: Stores recently used information so that it can be quickly accessed at a later
time.
- `"concurrentBuildLimit"`: The maximum number of concurrent builds that are allowed for
this project. New builds are only started if the current number of builds is less than or
equal to this limit. If the current build count meets this limit, new builds are throttled
and are not run. To remove this limit, set this value to -1.
- `"description"`: A new or replacement description of the build project.
- `"encryptionKey"`: The Key Management Service customer master key (CMK) to be used for
encrypting the build output artifacts. You can use a cross-account KMS key to encrypt the
build output artifacts if your service role has permission to that key. You can specify
either the Amazon Resource Name (ARN) of the CMK or, if available, the CMK's alias (using
the format alias/<alias-name>).
- `"environment"`: Information to be changed about the build environment for the build
project.
- `"fileSystemLocations"`: An array of ProjectFileSystemLocation objects for a CodeBuild
build project. A ProjectFileSystemLocation object specifies the identifier, location,
mountOptions, mountPoint, and type of a file system created using Amazon Elastic File
System.
- `"logsConfig"`: Information about logs for the build project. A project can create logs
in CloudWatch Logs, logs in an S3 bucket, or both.
- `"queuedTimeoutInMinutes"`: The number of minutes a build is allowed to be queued before
it times out.
- `"secondaryArtifacts"`: An array of ProjectArtifact objects.
- `"secondarySourceVersions"`: An array of ProjectSourceVersion objects. If
secondarySourceVersions is specified at the build level, then they take over these
secondarySourceVersions (at the project level).
- `"secondarySources"`: An array of ProjectSource objects.
- `"serviceRole"`: The replacement ARN of the IAM role that enables CodeBuild to interact
with dependent Amazon Web Services services on behalf of the Amazon Web Services account.
- `"source"`: Information to be changed about the build input source code for the build
project.
- `"sourceVersion"`: A version of the build input to be built for this project. If not
specified, the latest version is used. If specified, it must be one of: For CodeCommit:
the commit ID, branch, or Git tag to use. For GitHub: the commit ID, pull request ID,
branch name, or tag name that corresponds to the version of the source code you want to
build. If a pull request ID is specified, it must use the format pr/pull-request-ID (for
example pr/25). If a branch name is specified, the branch's HEAD commit ID is used. If not
specified, the default branch's HEAD commit ID is used. For GitLab: the commit ID,
branch, or Git tag to use. For Bitbucket: the commit ID, branch name, or tag name that
corresponds to the version of the source code you want to build. If a branch name is
specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD
commit ID is used. For Amazon S3: the version ID of the object that represents the build
input ZIP file to use. If sourceVersion is specified at the build level, then that
version takes precedence over this sourceVersion (at the project level). For more
information, see Source Version Sample with CodeBuild in the CodeBuild User Guide.
- `"tags"`: An updated list of tag key and value pairs associated with this build project.
These tags are available for use by Amazon Web Services services that support CodeBuild
build project tags.
- `"timeoutInMinutes"`: The replacement value in minutes, from 5 to 2160 (36 hours), for
CodeBuild to wait before timing out any related build that did not get marked as completed.
- `"vpcConfig"`: VpcConfig enables CodeBuild to access resources in an Amazon VPC.
"""
function update_project(name; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"UpdateProject",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_project(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"UpdateProject",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_project_visibility(project_arn, project_visibility)
update_project_visibility(project_arn, project_visibility, params::Dict{String,<:Any})
Changes the public visibility for a project. The project's build results, logs, and
artifacts are available to the general public. For more information, see Public build
projects in the CodeBuild User Guide. The following should be kept in mind when making
your projects public: All of a project's build results, logs, and artifacts, including
builds that were run when the project was private, are available to the general public.
All build logs and artifacts are available to the public. Environment variables, source
code, and other sensitive information may have been output to the build logs and artifacts.
You must be careful about what information is output to the build logs. Some best practice
are: Do not store sensitive values in environment variables. We recommend that you use an
Amazon EC2 Systems Manager Parameter Store or Secrets Manager to store sensitive values.
Follow Best practices for using webhooks in the CodeBuild User Guide to limit which
entities can trigger a build, and do not store the buildspec in the project itself, to
ensure that your webhooks are as secure as possible. A malicious user can use public
builds to distribute malicious artifacts. We recommend that you review all pull requests to
verify that the pull request is a legitimate change. We also recommend that you validate
any artifacts with their checksums to make sure that the correct artifacts are being
downloaded.
# Arguments
- `project_arn`: The Amazon Resource Name (ARN) of the build project.
- `project_visibility`:
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"resourceAccessRole"`: The ARN of the IAM role that enables CodeBuild to access the
CloudWatch Logs and Amazon S3 artifacts for the project's builds.
"""
function update_project_visibility(
projectArn, projectVisibility; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"UpdateProjectVisibility",
Dict{String,Any}(
"projectArn" => projectArn, "projectVisibility" => projectVisibility
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_project_visibility(
projectArn,
projectVisibility,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"UpdateProjectVisibility",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"projectArn" => projectArn, "projectVisibility" => projectVisibility
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_report_group(arn)
update_report_group(arn, params::Dict{String,<:Any})
Updates a report group.
# Arguments
- `arn`: The ARN of the report group to update.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"exportConfig"`: Used to specify an updated export type. Valid values are: S3: The
report results are exported to an S3 bucket. NO_EXPORT: The report results are not
exported.
- `"tags"`: An updated list of tag key and value pairs associated with this report group.
These tags are available for use by Amazon Web Services services that support CodeBuild
report group tags.
"""
function update_report_group(arn; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"UpdateReportGroup",
Dict{String,Any}("arn" => arn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_report_group(
arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codebuild(
"UpdateReportGroup",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_webhook(project_name)
update_webhook(project_name, params::Dict{String,<:Any})
Updates the webhook associated with an CodeBuild build project. If you use Bitbucket
for your repository, rotateSecret is ignored.
# Arguments
- `project_name`: The name of the CodeBuild project.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"branchFilter"`: A regular expression used to determine which repository branches are
built when a webhook is triggered. If the name of a branch matches the regular expression,
then it is built. If branchFilter is empty, then all branches are built. It is
recommended that you use filterGroups instead of branchFilter.
- `"buildType"`: Specifies the type of build this webhook will trigger.
- `"filterGroups"`: An array of arrays of WebhookFilter objects used to determine if a
webhook event can trigger a build. A filter group must contain at least one EVENT
WebhookFilter.
- `"rotateSecret"`: A boolean value that specifies whether the associated GitHub
repository's secret token should be updated. If you use Bitbucket for your repository,
rotateSecret is ignored.
"""
function update_webhook(projectName; aws_config::AbstractAWSConfig=global_aws_config())
return codebuild(
"UpdateWebhook",
Dict{String,Any}("projectName" => projectName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_webhook(
projectName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codebuild(
"UpdateWebhook",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("projectName" => projectName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 51625 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codecatalyst
using AWS.Compat
using AWS.UUIDs
"""
create_access_token(name)
create_access_token(name, params::Dict{String,<:Any})
Creates a personal access token (PAT) for the current user. A personal access token (PAT)
is similar to a password. It is associated with your user identity for use across all
spaces and projects in Amazon CodeCatalyst. You use PATs to access CodeCatalyst from
resources that include integrated development environments (IDEs) and Git-based source
repositories. PATs represent you in Amazon CodeCatalyst and you can manage them in your
user settings.For more information, see Managing personal access tokens in Amazon
CodeCatalyst.
# Arguments
- `name`: The friendly name of the personal access token.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"expiresTime"`: The date and time the personal access token expires, in coordinated
universal time (UTC) timestamp format as specified in RFC 3339.
"""
function create_access_token(name; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"PUT",
"/v1/accessTokens",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_access_token(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/accessTokens",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_dev_environment(instance_type, persistent_storage, project_name, space_name)
create_dev_environment(instance_type, persistent_storage, project_name, space_name, params::Dict{String,<:Any})
Creates a Dev Environment in Amazon CodeCatalyst, a cloud-based development environment
that you can use to quickly work on the code stored in the source repositories of your
project. When created in the Amazon CodeCatalyst console, by default a Dev Environment is
configured to have a 2 core processor, 4GB of RAM, and 16GB of persistent storage. None of
these defaults apply to a Dev Environment created programmatically.
# Arguments
- `instance_type`: The Amazon EC2 instace type to use for the Dev Environment.
- `persistent_storage`: Information about the amount of storage allocated to the Dev
Environment. By default, a Dev Environment is configured to have 16GB of persistent
storage when created from the Amazon CodeCatalyst console, but there is no default when
programmatically creating a Dev Environment. Valid values for persistent storage are based
on memory sizes in 16GB increments. Valid values are 16, 32, and 64.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: The user-defined alias for a Dev Environment.
- `"clientToken"`: A user-specified idempotency token. Idempotency ensures that an API
request completes only once. With an idempotent request, if the original request completes
successfully, the subsequent retries return the result from the original successful request
and have no additional effect.
- `"ides"`: Information about the integrated development environment (IDE) configured for a
Dev Environment. An IDE is required to create a Dev Environment. For Dev Environment
creation, this field contains configuration information and must be provided.
- `"inactivityTimeoutMinutes"`: The amount of time the Dev Environment will run without any
activity detected before stopping, in minutes. Only whole integers are allowed. Dev
Environments consume compute minutes when running.
- `"repositories"`: The source repository that contains the branch to clone into the Dev
Environment.
- `"vpcConnectionName"`: The name of the connection that will be used to connect to Amazon
VPC, if any.
"""
function create_dev_environment(
instanceType,
persistentStorage,
projectName,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments",
Dict{String,Any}(
"instanceType" => instanceType, "persistentStorage" => persistentStorage
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_dev_environment(
instanceType,
persistentStorage,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"instanceType" => instanceType, "persistentStorage" => persistentStorage
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_project(display_name, space_name)
create_project(display_name, space_name, params::Dict{String,<:Any})
Creates a project in a specified space.
# Arguments
- `display_name`: The friendly name of the project that will be displayed to users.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the project. This description will be displayed to
all users of the project. We recommend providing a brief description of the project and its
intended purpose.
"""
function create_project(
displayName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects",
Dict{String,Any}("displayName" => displayName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_project(
displayName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("displayName" => displayName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_source_repository(name, project_name, space_name)
create_source_repository(name, project_name, space_name, params::Dict{String,<:Any})
Creates an empty Git-based source repository in a specified project. The repository is
created with an initial empty commit with a default branch named main.
# Arguments
- `name`: The name of the source repository. For more information about name requirements,
see Quotas for source repositories.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the source repository.
"""
function create_source_repository(
name, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_source_repository(
name,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_source_repository_branch(name, project_name, source_repository_name, space_name)
create_source_repository_branch(name, project_name, source_repository_name, space_name, params::Dict{String,<:Any})
Creates a branch in a specified source repository in Amazon CodeCatalyst. This API only
creates a branch in a source repository hosted in Amazon CodeCatalyst. You cannot use this
API to create a branch in a linked repository.
# Arguments
- `name`: The name for the branch you're creating.
- `project_name`: The name of the project in the space.
- `source_repository_name`: The name of the repository where you want to create a branch.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"headCommitId"`: The commit ID in an existing branch from which you want to create the
new branch.
"""
function create_source_repository_branch(
name,
projectName,
sourceRepositoryName,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/branches/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_source_repository_branch(
name,
projectName,
sourceRepositoryName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/branches/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_access_token(id)
delete_access_token(id, params::Dict{String,<:Any})
Deletes a specified personal access token (PAT). A personal access token can only be
deleted by the user who created it.
# Arguments
- `id`: The ID of the personal access token to delete. You can find the IDs of all PATs
associated with your Amazon Web Services Builder ID in a space by calling ListAccessTokens.
"""
function delete_access_token(id; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"DELETE",
"/v1/accessTokens/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_access_token(
id, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"DELETE",
"/v1/accessTokens/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_dev_environment(id, project_name, space_name)
delete_dev_environment(id, project_name, space_name, params::Dict{String,<:Any})
Deletes a Dev Environment.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment you want to delete. To
retrieve a list of Dev Environment IDs, use ListDevEnvironments.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function delete_dev_environment(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_dev_environment(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_project(name, space_name)
delete_project(name, space_name, params::Dict{String,<:Any})
Deletes a project in a space.
# Arguments
- `name`: The name of the project in the space. To retrieve a list of project names, use
ListProjects.
- `space_name`: The name of the space.
"""
function delete_project(name, spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_project(
name,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_source_repository(name, project_name, space_name)
delete_source_repository(name, project_name, space_name, params::Dict{String,<:Any})
Deletes a source repository in Amazon CodeCatalyst. You cannot use this API to delete a
linked repository. It can only be used to delete a Amazon CodeCatalyst source repository.
# Arguments
- `name`: The name of the source repository.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function delete_source_repository(
name, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_source_repository(
name,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_space(name)
delete_space(name, params::Dict{String,<:Any})
Deletes a space. Deleting a space cannot be undone. Additionally, since space names must
be unique across Amazon CodeCatalyst, you cannot reuse names of deleted spaces.
# Arguments
- `name`: The name of the space. To retrieve a list of space names, use ListSpaces.
"""
function delete_space(name; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"DELETE",
"/v1/spaces/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_space(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_dev_environment(id, project_name, space_name)
get_dev_environment(id, project_name, space_name, params::Dict{String,<:Any})
Returns information about a Dev Environment for a source repository in a project. Dev
Environments are specific to the user who creates them.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment for which you want to view
information. To retrieve a list of Dev Environment IDs, use ListDevEnvironments.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function get_dev_environment(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_dev_environment(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_project(name, space_name)
get_project(name, space_name, params::Dict{String,<:Any})
Returns information about a project.
# Arguments
- `name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function get_project(name, spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_project(
name,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_source_repository(name, project_name, space_name)
get_source_repository(name, project_name, space_name, params::Dict{String,<:Any})
Returns information about a source repository.
# Arguments
- `name`: The name of the source repository.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function get_source_repository(
name, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_source_repository(
name,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_source_repository_clone_urls(project_name, source_repository_name, space_name)
get_source_repository_clone_urls(project_name, source_repository_name, space_name, params::Dict{String,<:Any})
Returns information about the URLs that can be used with a Git client to clone a source
repository.
# Arguments
- `project_name`: The name of the project in the space.
- `source_repository_name`: The name of the source repository.
- `space_name`: The name of the space.
"""
function get_source_repository_clone_urls(
projectName,
sourceRepositoryName,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/cloneUrls";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_source_repository_clone_urls(
projectName,
sourceRepositoryName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/cloneUrls",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_space(name)
get_space(name, params::Dict{String,<:Any})
Returns information about an space.
# Arguments
- `name`: The name of the space.
"""
function get_space(name; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"GET", "/v1/spaces/$(name)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_space(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/v1/spaces/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_subscription(space_name)
get_subscription(space_name, params::Dict{String,<:Any})
Returns information about the Amazon Web Services account used for billing purposes and the
billing plan for the space.
# Arguments
- `space_name`: The name of the space.
"""
function get_subscription(spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/subscription";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_subscription(
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/subscription",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_user_details()
get_user_details(params::Dict{String,<:Any})
Returns information about a user.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"id"`: The system-generated unique ID of the user.
- `"userName"`: The name of the user as displayed in Amazon CodeCatalyst.
"""
function get_user_details(; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"GET", "/userDetails"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_user_details(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/userDetails",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_workflow(id, project_name, space_name)
get_workflow(id, project_name, space_name, params::Dict{String,<:Any})
Returns information about a workflow.
# Arguments
- `id`: The ID of the workflow. To rerieve a list of workflow IDs, use ListWorkflows.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function get_workflow(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflows/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_workflow(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflows/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_workflow_run(id, project_name, space_name)
get_workflow_run(id, project_name, space_name, params::Dict{String,<:Any})
Returns information about a specified run of a workflow.
# Arguments
- `id`: The ID of the workflow run. To retrieve a list of workflow run IDs, use
ListWorkflowRuns.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function get_workflow_run(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_workflow_run(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"GET",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_access_tokens()
list_access_tokens(params::Dict{String,<:Any})
Lists all personal access tokens (PATs) associated with the user who calls the API. You can
only list PATs associated with your Amazon Web Services Builder ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_access_tokens(; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"POST", "/v1/accessTokens"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_access_tokens(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST",
"/v1/accessTokens",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_dev_environment_sessions(dev_environment_id, project_name, space_name)
list_dev_environment_sessions(dev_environment_id, project_name, space_name, params::Dict{String,<:Any})
Retrieves a list of active sessions for a Dev Environment in a project.
# Arguments
- `dev_environment_id`: The system-generated unique ID of the Dev Environment.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_dev_environment_sessions(
devEnvironmentId,
projectName,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(devEnvironmentId)/sessions";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_dev_environment_sessions(
devEnvironmentId,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(devEnvironmentId)/sessions",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_dev_environments(space_name)
list_dev_environments(space_name, params::Dict{String,<:Any})
Retrieves a list of Dev Environments in a project.
# Arguments
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: Information about filters to apply to narrow the results returned in the
list.
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
- `"projectName"`: The name of the project in the space.
"""
function list_dev_environments(spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/devEnvironments";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_dev_environments(
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/devEnvironments",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_event_logs(end_time, space_name, start_time)
list_event_logs(end_time, space_name, start_time, params::Dict{String,<:Any})
Retrieves a list of events that occurred during a specific time in a space. You can use
these events to audit user and system activity in a space. For more information, see
Monitoring in the Amazon CodeCatalyst User Guide. ListEventLogs guarantees events for the
last 30 days in a given space. You can also view and retrieve a list of management events
over the last 90 days for Amazon CodeCatalyst in the CloudTrail console by viewing Event
history, or by creating a trail to create and maintain a record of events that extends past
90 days. For more information, see Working with CloudTrail Event History and Working with
CloudTrail trails.
# Arguments
- `end_time`: The time after which you do not want any events retrieved, in coordinated
universal time (UTC) timestamp format as specified in RFC 3339.
- `space_name`: The name of the space.
- `start_time`: The date and time when you want to start retrieving events, in coordinated
universal time (UTC) timestamp format as specified in RFC 3339.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"eventName"`: The name of the event.
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_event_logs(
endTime, spaceName, startTime; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/eventLogs",
Dict{String,Any}("endTime" => endTime, "startTime" => startTime);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_event_logs(
endTime,
spaceName,
startTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/eventLogs",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("endTime" => endTime, "startTime" => startTime),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_projects(space_name)
list_projects(space_name, params::Dict{String,<:Any})
Retrieves a list of projects.
# Arguments
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filters"`: Information about filters to apply to narrow the results returned in the
list.
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_projects(spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_projects(
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_source_repositories(project_name, space_name)
list_source_repositories(project_name, space_name, params::Dict{String,<:Any})
Retrieves a list of source repositories in a project.
# Arguments
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_source_repositories(
projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_source_repositories(
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_source_repository_branches(project_name, source_repository_name, space_name)
list_source_repository_branches(project_name, source_repository_name, space_name, params::Dict{String,<:Any})
Retrieves a list of branches in a specified source repository.
# Arguments
- `project_name`: The name of the project in the space.
- `source_repository_name`: The name of the source repository.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_source_repository_branches(
projectName,
sourceRepositoryName,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/branches";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_source_repository_branches(
projectName,
sourceRepositoryName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/sourceRepositories/$(sourceRepositoryName)/branches",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_spaces()
list_spaces(params::Dict{String,<:Any})
Retrieves a list of spaces.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
"""
function list_spaces(; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"POST", "/v1/spaces"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_spaces(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST", "/v1/spaces", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_workflow_runs(project_name, space_name)
list_workflow_runs(project_name, space_name, params::Dict{String,<:Any})
Retrieves a list of workflow runs of a specified workflow.
# Arguments
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
- `"sortBy"`: Information used to sort the items in the returned list.
- `"workflowId"`: The ID of the workflow. To retrieve a list of workflow IDs, use
ListWorkflows.
"""
function list_workflow_runs(
projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_workflow_runs(
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_workflows(project_name, space_name)
list_workflows(project_name, space_name, params::Dict{String,<:Any})
Retrieves a list of workflows in a specified project.
# Arguments
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to show in a single call to this API. If
the number of results is larger than the number you specified, the response will include a
NextToken element, which you can use to obtain additional results.
- `"nextToken"`: A token returned from a call to this API to indicate the next batch of
results to return, if any.
- `"sortBy"`: Information used to sort the items in the returned list.
"""
function list_workflows(
projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflows";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_workflows(
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"POST",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflows",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_dev_environment(id, project_name, space_name)
start_dev_environment(id, project_name, space_name, params::Dict{String,<:Any})
Starts a specified Dev Environment and puts it into an active state.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ides"`: Information about the integrated development environment (IDE) configured for a
Dev Environment.
- `"inactivityTimeoutMinutes"`: The amount of time the Dev Environment will run without any
activity detected before stopping, in minutes. Only whole integers are allowed. Dev
Environments consume compute minutes when running.
- `"instanceType"`: The Amazon EC2 instace type to use for the Dev Environment.
"""
function start_dev_environment(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/start";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_dev_environment(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/start",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_dev_environment_session(id, project_name, session_configuration, space_name)
start_dev_environment_session(id, project_name, session_configuration, space_name, params::Dict{String,<:Any})
Starts a session for a specified Dev Environment.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment.
- `project_name`: The name of the project in the space.
- `session_configuration`:
- `space_name`: The name of the space.
"""
function start_dev_environment_session(
id,
projectName,
sessionConfiguration,
spaceName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/session",
Dict{String,Any}("sessionConfiguration" => sessionConfiguration);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_dev_environment_session(
id,
projectName,
sessionConfiguration,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/session",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("sessionConfiguration" => sessionConfiguration),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_workflow_run(project_name, space_name, workflow_id)
start_workflow_run(project_name, space_name, workflow_id, params::Dict{String,<:Any})
Begins a run of a specified workflow.
# Arguments
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
- `workflow_id`: The system-generated unique ID of the workflow. To retrieve a list of
workflow IDs, use ListWorkflows.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientToken"`: A user-specified idempotency token. Idempotency ensures that an API
request completes only once. With an idempotent request, if the original request completes
successfully, the subsequent retries return the result from the original successful request
and have no additional effect.
"""
function start_workflow_run(
projectName, spaceName, workflowId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns",
Dict{String,Any}("workflowId" => workflowId, "clientToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_workflow_run(
projectName,
spaceName,
workflowId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/workflowRuns",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"workflowId" => workflowId, "clientToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_dev_environment(id, project_name, space_name)
stop_dev_environment(id, project_name, space_name, params::Dict{String,<:Any})
Pauses a specified Dev Environment and places it in a non-running state. Stopped Dev
Environments do not consume compute minutes.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
"""
function stop_dev_environment(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/stop";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_dev_environment(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PUT",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/stop",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_dev_environment_session(id, project_name, session_id, space_name)
stop_dev_environment_session(id, project_name, session_id, space_name, params::Dict{String,<:Any})
Stops a session for a specified Dev Environment.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment. To obtain this ID, use
ListDevEnvironments.
- `project_name`: The name of the project in the space.
- `session_id`: The system-generated unique ID of the Dev Environment session. This ID is
returned by StartDevEnvironmentSession.
- `space_name`: The name of the space.
"""
function stop_dev_environment_session(
id, projectName, sessionId, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/session/$(sessionId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_dev_environment_session(
id,
projectName,
sessionId,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"DELETE",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)/session/$(sessionId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_dev_environment(id, project_name, space_name)
update_dev_environment(id, project_name, space_name, params::Dict{String,<:Any})
Changes one or more values for a Dev Environment. Updating certain values of the Dev
Environment will cause a restart.
# Arguments
- `id`: The system-generated unique ID of the Dev Environment.
- `project_name`: The name of the project in the space.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alias"`: The user-specified alias for the Dev Environment. Changing this value will not
cause a restart.
- `"clientToken"`: A user-specified idempotency token. Idempotency ensures that an API
request completes only once. With an idempotent request, if the original request completes
successfully, the subsequent retries return the result from the original successful request
and have no additional effect.
- `"ides"`: Information about the integrated development environment (IDE) configured for a
Dev Environment.
- `"inactivityTimeoutMinutes"`: The amount of time the Dev Environment will run without any
activity detected before stopping, in minutes. Only whole integers are allowed. Dev
Environments consume compute minutes when running. Changing this value will cause a
restart of the Dev Environment if it is running.
- `"instanceType"`: The Amazon EC2 instace type to use for the Dev Environment. Changing
this value will cause a restart of the Dev Environment if it is running.
"""
function update_dev_environment(
id, projectName, spaceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PATCH",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_dev_environment(
id,
projectName,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PATCH",
"/v1/spaces/$(spaceName)/projects/$(projectName)/devEnvironments/$(id)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_project(name, space_name)
update_project(name, space_name, params::Dict{String,<:Any})
Changes one or more values for a project.
# Arguments
- `name`: The name of the project.
- `space_name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the project.
"""
function update_project(name, spaceName; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"PATCH",
"/v1/spaces/$(spaceName)/projects/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_project(
name,
spaceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecatalyst(
"PATCH",
"/v1/spaces/$(spaceName)/projects/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_space(name)
update_space(name, params::Dict{String,<:Any})
Changes one or more values for a space.
# Arguments
- `name`: The name of the space.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: The description of the space.
"""
function update_space(name; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"PATCH",
"/v1/spaces/$(name)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_space(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"PATCH",
"/v1/spaces/$(name)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
verify_session()
verify_session(params::Dict{String,<:Any})
Verifies whether the calling user has a valid Amazon CodeCatalyst login and session. If
successful, this returns the ID of the user in Amazon CodeCatalyst.
"""
function verify_session(; aws_config::AbstractAWSConfig=global_aws_config())
return codecatalyst(
"GET", "/session"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function verify_session(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecatalyst(
"GET", "/session", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 154269 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codecommit
using AWS.Compat
using AWS.UUIDs
"""
associate_approval_rule_template_with_repository(approval_rule_template_name, repository_name)
associate_approval_rule_template_with_repository(approval_rule_template_name, repository_name, params::Dict{String,<:Any})
Creates an association between an approval rule template and a specified repository. Then,
the next time a pull request is created in the repository where the destination reference
(if specified) matches the destination reference (branch) for the pull request, an approval
rule that matches the template conditions is automatically created for that pull request.
If no destination references are specified in the template, an approval rule that matches
the template contents is created for all pull requests in that repository.
# Arguments
- `approval_rule_template_name`: The name for the approval rule template.
- `repository_name`: The name of the repository that you want to associate with the
template.
"""
function associate_approval_rule_template_with_repository(
approvalRuleTemplateName,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"AssociateApprovalRuleTemplateWithRepository",
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_approval_rule_template_with_repository(
approvalRuleTemplateName,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"AssociateApprovalRuleTemplateWithRepository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_associate_approval_rule_template_with_repositories(approval_rule_template_name, repository_names)
batch_associate_approval_rule_template_with_repositories(approval_rule_template_name, repository_names, params::Dict{String,<:Any})
Creates an association between an approval rule template and one or more specified
repositories.
# Arguments
- `approval_rule_template_name`: The name of the template you want to associate with one or
more repositories.
- `repository_names`: The names of the repositories you want to associate with the
template. The length constraint limit is for each string in the array. The array itself
can be empty.
"""
function batch_associate_approval_rule_template_with_repositories(
approvalRuleTemplateName,
repositoryNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchAssociateApprovalRuleTemplateWithRepositories",
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryNames" => repositoryNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_associate_approval_rule_template_with_repositories(
approvalRuleTemplateName,
repositoryNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchAssociateApprovalRuleTemplateWithRepositories",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryNames" => repositoryNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_describe_merge_conflicts(destination_commit_specifier, merge_option, repository_name, source_commit_specifier)
batch_describe_merge_conflicts(destination_commit_specifier, merge_option, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Returns information about one or more merge conflicts in the attempted merge of two commit
specifiers using the squash or three-way merge strategy.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `merge_option`: The merge option or strategy you want to use to merge the code.
- `repository_name`: The name of the repository that contains the merge conflicts you want
to review.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"filePaths"`: The path of the target files used to describe the conflicts. If not
specified, the default is all conflict files.
- `"maxConflictFiles"`: The maximum number of files to include in the output.
- `"maxMergeHunks"`: The maximum number of merge hunks to include in the output.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function batch_describe_merge_conflicts(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchDescribeMergeConflicts",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_describe_merge_conflicts(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchDescribeMergeConflicts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_disassociate_approval_rule_template_from_repositories(approval_rule_template_name, repository_names)
batch_disassociate_approval_rule_template_from_repositories(approval_rule_template_name, repository_names, params::Dict{String,<:Any})
Removes the association between an approval rule template and one or more specified
repositories.
# Arguments
- `approval_rule_template_name`: The name of the template that you want to disassociate
from one or more repositories.
- `repository_names`: The repository names that you want to disassociate from the approval
rule template. The length constraint limit is for each string in the array. The array
itself can be empty.
"""
function batch_disassociate_approval_rule_template_from_repositories(
approvalRuleTemplateName,
repositoryNames;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchDisassociateApprovalRuleTemplateFromRepositories",
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryNames" => repositoryNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_disassociate_approval_rule_template_from_repositories(
approvalRuleTemplateName,
repositoryNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchDisassociateApprovalRuleTemplateFromRepositories",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryNames" => repositoryNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_commits(commit_ids, repository_name)
batch_get_commits(commit_ids, repository_name, params::Dict{String,<:Any})
Returns information about the contents of one or more commits in a repository.
# Arguments
- `commit_ids`: The full commit IDs of the commits to get information about. You must
supply the full SHA IDs of each commit. You cannot use shortened SHA IDs.
- `repository_name`: The name of the repository that contains the commits.
"""
function batch_get_commits(
commitIds, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"BatchGetCommits",
Dict{String,Any}("commitIds" => commitIds, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_commits(
commitIds,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchGetCommits",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"commitIds" => commitIds, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_repositories(repository_names)
batch_get_repositories(repository_names, params::Dict{String,<:Any})
Returns information about one or more repositories. The description field for a repository
accepts all HTML characters and all valid Unicode characters. Applications that do not
HTML-encode the description and display it in a webpage can expose users to potentially
malicious code. Make sure that you HTML-encode the description field in any application
that uses this API to display the repository description on a webpage.
# Arguments
- `repository_names`: The names of the repositories to get information about. The length
constraint limit is for each string in the array. The array itself can be empty.
"""
function batch_get_repositories(
repositoryNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"BatchGetRepositories",
Dict{String,Any}("repositoryNames" => repositoryNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_repositories(
repositoryNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"BatchGetRepositories",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("repositoryNames" => repositoryNames), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_approval_rule_template(approval_rule_template_content, approval_rule_template_name)
create_approval_rule_template(approval_rule_template_content, approval_rule_template_name, params::Dict{String,<:Any})
Creates a template for approval rules that can then be associated with one or more
repositories in your Amazon Web Services account. When you associate a template with a
repository, CodeCommit creates an approval rule that matches the conditions of the template
for all pull requests that meet the conditions of the template. For more information, see
AssociateApprovalRuleTemplateWithRepository.
# Arguments
- `approval_rule_template_content`: The content of the approval rule that is created on
pull requests in associated repositories. If you specify one or more destination references
(branches), approval rules are created in an associated repository only if their
destination references (branches) match those specified in the template. When you create
the content of the approval rule template, you can specify approvers in an approval pool in
one of two ways: CodeCommitApprovers: This option only requires an Amazon Web Services
account and a resource. It can be used for both IAM users and federated access users whose
name matches the provided resource name. This is a very powerful option that offers a great
deal of flexibility. For example, if you specify the Amazon Web Services account
123456789012 and Mary_Major, all of the following are counted as approvals coming from that
user: An IAM user in the account (arn:aws:iam::123456789012:user/Mary_Major) A
federated user identified in IAM as Mary_Major
(arn:aws:sts::123456789012:federated-user/Mary_Major) This option does not recognize an
active session of someone assuming the role of CodeCommitReview with a role session name of
Mary_Major (arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you
include a wildcard (*Mary_Major). Fully qualified ARN: This option allows you to specify
the fully qualified Amazon Resource Name (ARN) of the IAM user or role. For more
information about IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User
Guide.
- `approval_rule_template_name`: The name of the approval rule template. Provide
descriptive names, because this name is applied to the approval rules created automatically
in associated repositories.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"approvalRuleTemplateDescription"`: The description of the approval rule template.
Consider providing a description that explains what this template does and when it might be
appropriate to associate it with repositories.
"""
function create_approval_rule_template(
approvalRuleTemplateContent,
approvalRuleTemplateName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateApprovalRuleTemplate",
Dict{String,Any}(
"approvalRuleTemplateContent" => approvalRuleTemplateContent,
"approvalRuleTemplateName" => approvalRuleTemplateName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_approval_rule_template(
approvalRuleTemplateContent,
approvalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateApprovalRuleTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateContent" => approvalRuleTemplateContent,
"approvalRuleTemplateName" => approvalRuleTemplateName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_branch(branch_name, commit_id, repository_name)
create_branch(branch_name, commit_id, repository_name, params::Dict{String,<:Any})
Creates a branch in a repository and points the branch to a commit. Calling the create
branch operation does not set a repository's default branch. To do this, call the update
default branch operation.
# Arguments
- `branch_name`: The name of the new branch to create.
- `commit_id`: The ID of the commit to point the new branch to.
- `repository_name`: The name of the repository in which you want to create the new branch.
"""
function create_branch(
branchName, commitId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"CreateBranch",
Dict{String,Any}(
"branchName" => branchName,
"commitId" => commitId,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_branch(
branchName,
commitId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateBranch",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"branchName" => branchName,
"commitId" => commitId,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_commit(branch_name, repository_name)
create_commit(branch_name, repository_name, params::Dict{String,<:Any})
Creates a commit for a repository on the tip of a specified branch.
# Arguments
- `branch_name`: The name of the branch where you create the commit.
- `repository_name`: The name of the repository where you create the commit.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the commit. This information is used
as both the author and committer for the commit.
- `"commitMessage"`: The commit message you want to include in the commit. Commit messages
are limited to 256 KB. If no message is specified, a default message is used.
- `"deleteFiles"`: The files to delete in this commit. These files still exist in earlier
commits.
- `"email"`: The email address of the person who created the commit.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If true, a ..gitkeep file is
created for empty folders. The default is false.
- `"parentCommitId"`: The ID of the commit that is the parent of the commit you create. Not
required if this is an empty repository.
- `"putFiles"`: The files to add or update in this commit.
- `"setFileModes"`: The file modes to update for files in this commit.
"""
function create_commit(
branchName, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"CreateCommit",
Dict{String,Any}("branchName" => branchName, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_commit(
branchName,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"branchName" => branchName, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_pull_request(targets, title)
create_pull_request(targets, title, params::Dict{String,<:Any})
Creates a pull request in the specified repository.
# Arguments
- `targets`: The targets for the pull request, including the source of the code to be
reviewed (the source branch) and the destination where the creator of the pull request
intends the code to be merged after the pull request is closed (the destination branch).
- `title`: The title of the pull request. This title is used to identify the pull request
to other users in the repository.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, client-generated idempotency token that, when provided
in a request, ensures the request cannot be repeated with a changed parameter. If a request
is received with the same parameters and a token is included, the request returns
information about the initial request that used that token. The Amazon Web ServicesSDKs
prepopulate client request tokens. If you are using an Amazon Web ServicesSDK, an
idempotency token is created for you.
- `"description"`: A description of the pull request.
"""
function create_pull_request(
targets, title; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"CreatePullRequest",
Dict{String,Any}(
"targets" => targets, "title" => title, "clientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_pull_request(
targets,
title,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreatePullRequest",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"targets" => targets,
"title" => title,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_pull_request_approval_rule(approval_rule_content, approval_rule_name, pull_request_id)
create_pull_request_approval_rule(approval_rule_content, approval_rule_name, pull_request_id, params::Dict{String,<:Any})
Creates an approval rule for a pull request.
# Arguments
- `approval_rule_content`: The content of the approval rule, including the number of
approvals needed and the structure of an approval pool defined for approvals, if any. For
more information about approval pools, see the CodeCommit User Guide. When you create the
content of the approval rule, you can specify approvers in an approval pool in one of two
ways: CodeCommitApprovers: This option only requires an Amazon Web Services account and
a resource. It can be used for both IAM users and federated access users whose name matches
the provided resource name. This is a very powerful option that offers a great deal of
flexibility. For example, if you specify the Amazon Web Services account 123456789012 and
Mary_Major, all of the following would be counted as approvals coming from that user: An
IAM user in the account (arn:aws:iam::123456789012:user/Mary_Major) A federated user
identified in IAM as Mary_Major (arn:aws:sts::123456789012:federated-user/Mary_Major)
This option does not recognize an active session of someone assuming the role of
CodeCommitReview with a role session name of Mary_Major
(arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you include a
wildcard (*Mary_Major). Fully qualified ARN: This option allows you to specify the fully
qualified Amazon Resource Name (ARN) of the IAM user or role. For more information about
IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User Guide.
- `approval_rule_name`: The name for the approval rule.
- `pull_request_id`: The system-generated ID of the pull request for which you want to
create the approval rule.
"""
function create_pull_request_approval_rule(
approvalRuleContent,
approvalRuleName,
pullRequestId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreatePullRequestApprovalRule",
Dict{String,Any}(
"approvalRuleContent" => approvalRuleContent,
"approvalRuleName" => approvalRuleName,
"pullRequestId" => pullRequestId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_pull_request_approval_rule(
approvalRuleContent,
approvalRuleName,
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreatePullRequestApprovalRule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleContent" => approvalRuleContent,
"approvalRuleName" => approvalRuleName,
"pullRequestId" => pullRequestId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_repository(repository_name)
create_repository(repository_name, params::Dict{String,<:Any})
Creates a new, empty repository.
# Arguments
- `repository_name`: The name of the new repository to be created. The repository name
must be unique across the calling Amazon Web Services account. Repository names are limited
to 100 alphanumeric, dash, and underscore characters, and cannot include certain
characters. For more information about the limits on repository names, see Quotas in the
CodeCommit User Guide. The suffix .git is prohibited.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"kmsKeyId"`: The ID of the encryption key. You can view the ID of an encryption key in
the KMS console, or use the KMS APIs to programmatically retrieve a key ID. For more
information about acceptable values for kmsKeyID, see KeyId in the Decrypt API description
in the Key Management Service API Reference. If no key is specified, the default
aws/codecommit Amazon Web Services managed key is used.
- `"repositoryDescription"`: A comment or description about the new repository. The
description field for a repository accepts all HTML characters and all valid Unicode
characters. Applications that do not HTML-encode the description and display it in a
webpage can expose users to potentially malicious code. Make sure that you HTML-encode the
description field in any application that uses this API to display the repository
description on a webpage.
- `"tags"`: One or more tag key-value pairs to use when tagging this repository.
"""
function create_repository(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"CreateRepository",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_repository(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateRepository",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_unreferenced_merge_commit(destination_commit_specifier, merge_option, repository_name, source_commit_specifier)
create_unreferenced_merge_commit(destination_commit_specifier, merge_option, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Creates an unreferenced commit that represents the result of merging two branches using a
specified merge strategy. This can help you determine the outcome of a potential merge.
This API cannot be used with the fast-forward merge strategy because that strategy does not
create a merge commit. This unreferenced merge commit can only be accessed using the
GetCommit API or through git commands such as git fetch. To retrieve this commit, you must
specify its commit ID or otherwise reference it.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `merge_option`: The merge option or strategy you want to use to merge the code.
- `repository_name`: The name of the repository where you want to create the unreferenced
merge commit.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the unreferenced commit. This
information is used as both the author and committer for the commit.
- `"commitMessage"`: The commit message for the unreferenced commit.
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolution"`: If AUTOMERGE is the conflict resolution strategy, a list of
inputs to use when resolving conflicts during a merge.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"email"`: The email address for the person who created the unreferenced commit.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If this is specified as true, a
.gitkeep file is created for empty folders. The default is false.
"""
function create_unreferenced_merge_commit(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateUnreferencedMergeCommit",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_unreferenced_merge_commit(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"CreateUnreferencedMergeCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_approval_rule_template(approval_rule_template_name)
delete_approval_rule_template(approval_rule_template_name, params::Dict{String,<:Any})
Deletes a specified approval rule template. Deleting a template does not remove approval
rules on pull requests already created with the template.
# Arguments
- `approval_rule_template_name`: The name of the approval rule template to delete.
"""
function delete_approval_rule_template(
approvalRuleTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DeleteApprovalRuleTemplate",
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_approval_rule_template(
approvalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteApprovalRuleTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_branch(branch_name, repository_name)
delete_branch(branch_name, repository_name, params::Dict{String,<:Any})
Deletes a branch from a repository, unless that branch is the default branch for the
repository.
# Arguments
- `branch_name`: The name of the branch to delete.
- `repository_name`: The name of the repository that contains the branch to be deleted.
"""
function delete_branch(
branchName, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DeleteBranch",
Dict{String,Any}("branchName" => branchName, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_branch(
branchName,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteBranch",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"branchName" => branchName, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_comment_content(comment_id)
delete_comment_content(comment_id, params::Dict{String,<:Any})
Deletes the content of a comment made on a change, file, or commit in a repository.
# Arguments
- `comment_id`: The unique, system-generated ID of the comment. To get this ID, use
GetCommentsForComparedCommit or GetCommentsForPullRequest.
"""
function delete_comment_content(
commentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DeleteCommentContent",
Dict{String,Any}("commentId" => commentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_comment_content(
commentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteCommentContent",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("commentId" => commentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_file(branch_name, file_path, parent_commit_id, repository_name)
delete_file(branch_name, file_path, parent_commit_id, repository_name, params::Dict{String,<:Any})
Deletes a specified file from a specified branch. A commit is created on the branch that
contains the revision. The file still exists in the commits earlier to the commit that
contains the deletion.
# Arguments
- `branch_name`: The name of the branch where the commit that deletes the file is made.
- `file_path`: The fully qualified path to the file that to be deleted, including the full
name and extension of that file. For example, /examples/file.md is a fully qualified path
to a file named file.md in a folder named examples.
- `parent_commit_id`: The ID of the commit that is the tip of the branch where you want to
create the commit that deletes the file. This must be the HEAD commit for the branch. The
commit that deletes the file is created from this commit ID.
- `repository_name`: The name of the repository that contains the file to delete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitMessage"`: The commit message you want to include as part of deleting the file.
Commit messages are limited to 256 KB. If no message is specified, a default message is
used.
- `"email"`: The email address for the commit that deletes the file. If no email address is
specified, the email address is left blank.
- `"keepEmptyFolders"`: If a file is the only object in the folder or directory, specifies
whether to delete the folder or directory that contains the file. By default, empty folders
are deleted. This includes empty folders that are part of the directory structure. For
example, if the path to a file is dir1/dir2/dir3/dir4, and dir2 and dir3 are empty,
deleting the last file in dir4 also deletes the empty folders dir4, dir3, and dir2.
- `"name"`: The name of the author of the commit that deletes the file. If no name is
specified, the user's ARN is used as the author name and committer name.
"""
function delete_file(
branchName,
filePath,
parentCommitId,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteFile",
Dict{String,Any}(
"branchName" => branchName,
"filePath" => filePath,
"parentCommitId" => parentCommitId,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_file(
branchName,
filePath,
parentCommitId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteFile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"branchName" => branchName,
"filePath" => filePath,
"parentCommitId" => parentCommitId,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_pull_request_approval_rule(approval_rule_name, pull_request_id)
delete_pull_request_approval_rule(approval_rule_name, pull_request_id, params::Dict{String,<:Any})
Deletes an approval rule from a specified pull request. Approval rules can be deleted from
a pull request only if the pull request is open, and if the approval rule was created
specifically for a pull request and not generated from an approval rule template associated
with the repository where the pull request was created. You cannot delete an approval rule
from a merged or closed pull request.
# Arguments
- `approval_rule_name`: The name of the approval rule you want to delete.
- `pull_request_id`: The system-generated ID of the pull request that contains the approval
rule you want to delete.
"""
function delete_pull_request_approval_rule(
approvalRuleName, pullRequestId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DeletePullRequestApprovalRule",
Dict{String,Any}(
"approvalRuleName" => approvalRuleName, "pullRequestId" => pullRequestId
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_pull_request_approval_rule(
approvalRuleName,
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeletePullRequestApprovalRule",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleName" => approvalRuleName, "pullRequestId" => pullRequestId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_repository(repository_name)
delete_repository(repository_name, params::Dict{String,<:Any})
Deletes a repository. If a specified repository was already deleted, a null repository ID
is returned. Deleting a repository also deletes all associated objects and metadata. After
a repository is deleted, all future push calls to the deleted repository fail.
# Arguments
- `repository_name`: The name of the repository to delete.
"""
function delete_repository(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DeleteRepository",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_repository(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DeleteRepository",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_merge_conflicts(destination_commit_specifier, file_path, merge_option, repository_name, source_commit_specifier)
describe_merge_conflicts(destination_commit_specifier, file_path, merge_option, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Returns information about one or more merge conflicts in the attempted merge of two commit
specifiers using the squash or three-way merge strategy. If the merge option for the
attempted merge is specified as FAST_FORWARD_MERGE, an exception is thrown.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `file_path`: The path of the target files used to describe the conflicts.
- `merge_option`: The merge option or strategy you want to use to merge the code.
- `repository_name`: The name of the repository where you want to get information about a
merge conflict.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"maxMergeHunks"`: The maximum number of merge hunks to include in the output.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function describe_merge_conflicts(
destinationCommitSpecifier,
filePath,
mergeOption,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DescribeMergeConflicts",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"filePath" => filePath,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_merge_conflicts(
destinationCommitSpecifier,
filePath,
mergeOption,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DescribeMergeConflicts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"filePath" => filePath,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_pull_request_events(pull_request_id)
describe_pull_request_events(pull_request_id, params::Dict{String,<:Any})
Returns information about one or more pull request events.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actorArn"`: The Amazon Resource Name (ARN) of the user whose actions resulted in the
event. Examples include updating the pull request with more commits or changing the status
of a pull request.
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results. The default is 100 events, which is also the maximum number of events that can be
returned in a result.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
- `"pullRequestEventType"`: Optional. The pull request event type about which you want to
return information.
"""
function describe_pull_request_events(
pullRequestId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"DescribePullRequestEvents",
Dict{String,Any}("pullRequestId" => pullRequestId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_pull_request_events(
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DescribePullRequestEvents",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pullRequestId" => pullRequestId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_approval_rule_template_from_repository(approval_rule_template_name, repository_name)
disassociate_approval_rule_template_from_repository(approval_rule_template_name, repository_name, params::Dict{String,<:Any})
Removes the association between a template and a repository so that approval rules based on
the template are not automatically created when pull requests are created in the specified
repository. This does not delete any approval rules previously created for pull requests
through the template association.
# Arguments
- `approval_rule_template_name`: The name of the approval rule template to disassociate
from a specified repository.
- `repository_name`: The name of the repository you want to disassociate from the template.
"""
function disassociate_approval_rule_template_from_repository(
approvalRuleTemplateName,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DisassociateApprovalRuleTemplateFromRepository",
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_approval_rule_template_from_repository(
approvalRuleTemplateName,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"DisassociateApprovalRuleTemplateFromRepository",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
evaluate_pull_request_approval_rules(pull_request_id, revision_id)
evaluate_pull_request_approval_rules(pull_request_id, revision_id, params::Dict{String,<:Any})
Evaluates whether a pull request has met all the conditions specified in its associated
approval rules.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request you want to evaluate.
- `revision_id`: The system-generated ID for the pull request revision. To retrieve the
most recent revision ID for a pull request, use GetPullRequest.
"""
function evaluate_pull_request_approval_rules(
pullRequestId, revisionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"EvaluatePullRequestApprovalRules",
Dict{String,Any}("pullRequestId" => pullRequestId, "revisionId" => revisionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function evaluate_pull_request_approval_rules(
pullRequestId,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"EvaluatePullRequestApprovalRules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "revisionId" => revisionId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_approval_rule_template(approval_rule_template_name)
get_approval_rule_template(approval_rule_template_name, params::Dict{String,<:Any})
Returns information about a specified approval rule template.
# Arguments
- `approval_rule_template_name`: The name of the approval rule template for which you want
to get information.
"""
function get_approval_rule_template(
approvalRuleTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetApprovalRuleTemplate",
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_approval_rule_template(
approvalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetApprovalRuleTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_blob(blob_id, repository_name)
get_blob(blob_id, repository_name, params::Dict{String,<:Any})
Returns the base-64 encoded content of an individual blob in a repository.
# Arguments
- `blob_id`: The ID of the blob, which is its SHA-1 pointer.
- `repository_name`: The name of the repository that contains the blob.
"""
function get_blob(blobId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"GetBlob",
Dict{String,Any}("blobId" => blobId, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_blob(
blobId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetBlob",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("blobId" => blobId, "repositoryName" => repositoryName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_branch()
get_branch(params::Dict{String,<:Any})
Returns information about a repository branch, including its name and the last commit ID.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"branchName"`: The name of the branch for which you want to retrieve information.
- `"repositoryName"`: The name of the repository that contains the branch for which you
want to retrieve information.
"""
function get_branch(; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit("GetBranch"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET)
end
function get_branch(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetBranch", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
get_comment(comment_id)
get_comment(comment_id, params::Dict{String,<:Any})
Returns the content of a comment made on a change, file, or commit in a repository.
Reaction counts might include numbers from user identities who were deleted after the
reaction was made. For a count of reactions from active identities, use
GetCommentReactions.
# Arguments
- `comment_id`: The unique, system-generated ID of the comment. To get this ID, use
GetCommentsForComparedCommit or GetCommentsForPullRequest.
"""
function get_comment(commentId; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"GetComment",
Dict{String,Any}("commentId" => commentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_comment(
commentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetComment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("commentId" => commentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_comment_reactions(comment_id)
get_comment_reactions(comment_id, params::Dict{String,<:Any})
Returns information about reactions to a specified comment ID. Reactions from users who
have been deleted will not be included in the count.
# Arguments
- `comment_id`: The ID of the comment for which you want to get reactions information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results. The default is the same as the allowed maximum, 1,000.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
- `"reactionUserArn"`: Optional. The Amazon Resource Name (ARN) of the user or identity for
which you want to get reaction information.
"""
function get_comment_reactions(commentId; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"GetCommentReactions",
Dict{String,Any}("commentId" => commentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_comment_reactions(
commentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetCommentReactions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("commentId" => commentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_comments_for_compared_commit(after_commit_id, repository_name)
get_comments_for_compared_commit(after_commit_id, repository_name, params::Dict{String,<:Any})
Returns information about comments made on the comparison between two commits. Reaction
counts might include numbers from user identities who were deleted after the reaction was
made. For a count of reactions from active identities, use GetCommentReactions.
# Arguments
- `after_commit_id`: To establish the directionality of the comparison, the full commit ID
of the after commit.
- `repository_name`: The name of the repository where you want to compare commits.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"beforeCommitId"`: To establish the directionality of the comparison, the full commit ID
of the before commit.
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results. The default is 100 comments, but you can configure up to 500.
- `"nextToken"`: An enumeration token that when provided in a request, returns the next
batch of the results.
"""
function get_comments_for_compared_commit(
afterCommitId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetCommentsForComparedCommit",
Dict{String,Any}(
"afterCommitId" => afterCommitId, "repositoryName" => repositoryName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_comments_for_compared_commit(
afterCommitId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetCommentsForComparedCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"afterCommitId" => afterCommitId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_comments_for_pull_request(pull_request_id)
get_comments_for_pull_request(pull_request_id, params::Dict{String,<:Any})
Returns comments made on a pull request. Reaction counts might include numbers from user
identities who were deleted after the reaction was made. For a count of reactions from
active identities, use GetCommentReactions.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"afterCommitId"`: The full commit ID of the commit in the source branch that was the tip
of the branch at the time the comment was made. Requirement is conditional: afterCommitId
must be specified when repositoryName is included.
- `"beforeCommitId"`: The full commit ID of the commit in the destination branch that was
the tip of the branch at the time the pull request was created. Requirement is conditional:
beforeCommitId must be specified when repositoryName is included.
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results. The default is 100 comments. You can return up to 500 comments with a single
request.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
- `"repositoryName"`: The name of the repository that contains the pull request.
Requirement is conditional: repositoryName must be specified when beforeCommitId and
afterCommitId are included.
"""
function get_comments_for_pull_request(
pullRequestId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetCommentsForPullRequest",
Dict{String,Any}("pullRequestId" => pullRequestId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_comments_for_pull_request(
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetCommentsForPullRequest",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pullRequestId" => pullRequestId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_commit(commit_id, repository_name)
get_commit(commit_id, repository_name, params::Dict{String,<:Any})
Returns information about a commit, including commit message and committer information.
# Arguments
- `commit_id`: The commit ID. Commit IDs are the full SHA ID of the commit.
- `repository_name`: The name of the repository to which the commit was made.
"""
function get_commit(
commitId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetCommit",
Dict{String,Any}("commitId" => commitId, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_commit(
commitId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"commitId" => commitId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_differences(after_commit_specifier, repository_name)
get_differences(after_commit_specifier, repository_name, params::Dict{String,<:Any})
Returns information about the differences in a valid commit specifier (such as a branch,
tag, HEAD, commit ID, or other fully qualified reference). Results can be limited to a
specified path.
# Arguments
- `after_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit.
- `repository_name`: The name of the repository where you want to get differences.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"NextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
- `"afterPath"`: The file path in which to check differences. Limits the results to this
path. Can also be used to specify the changed name of a directory or folder, if it has
changed. If not specified, differences are shown for all paths.
- `"beforeCommitSpecifier"`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, the full commit ID). Optional. If not specified, all
changes before the afterCommitSpecifier value are shown. If you do not use
beforeCommitSpecifier in your request, consider limiting the results with maxResults.
- `"beforePath"`: The file path in which to check for differences. Limits the results to
this path. Can also be used to specify the previous name of a directory or folder. If
beforePath and afterPath are not specified, differences are shown for all paths.
"""
function get_differences(
afterCommitSpecifier, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetDifferences",
Dict{String,Any}(
"afterCommitSpecifier" => afterCommitSpecifier,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_differences(
afterCommitSpecifier,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetDifferences",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"afterCommitSpecifier" => afterCommitSpecifier,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_file(file_path, repository_name)
get_file(file_path, repository_name, params::Dict{String,<:Any})
Returns the base-64 encoded contents of a specified file and its metadata.
# Arguments
- `file_path`: The fully qualified path to the file, including the full name and extension
of the file. For example, /examples/file.md is the fully qualified path to a file named
file.md in a folder named examples.
- `repository_name`: The name of the repository that contains the file.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitSpecifier"`: The fully quaified reference that identifies the commit that
contains the file. For example, you can specify a full commit ID, a tag, a branch name, or
a reference such as refs/heads/main. If none is provided, the head commit is used.
"""
function get_file(
filePath, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetFile",
Dict{String,Any}("filePath" => filePath, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_file(
filePath,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetFile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filePath" => filePath, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_folder(folder_path, repository_name)
get_folder(folder_path, repository_name, params::Dict{String,<:Any})
Returns the contents of a specified folder in a repository.
# Arguments
- `folder_path`: The fully qualified path to the folder whose contents are returned,
including the folder name. For example, /examples is a fully-qualified path to a folder
named examples that was created off of the root directory (/) of a repository.
- `repository_name`: The name of the repository.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitSpecifier"`: A fully qualified reference used to identify a commit that contains
the version of the folder's content to return. A fully qualified reference can be a commit
ID, branch name, tag, or reference such as HEAD. If no specifier is provided, the folder
content is returned as it exists in the HEAD commit.
"""
function get_folder(
folderPath, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetFolder",
Dict{String,Any}("folderPath" => folderPath, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_folder(
folderPath,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetFolder",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"folderPath" => folderPath, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_merge_commit(destination_commit_specifier, repository_name, source_commit_specifier)
get_merge_commit(destination_commit_specifier, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Returns information about a specified merge commit.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `repository_name`: The name of the repository that contains the merge commit about which
you want to get information.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
"""
function get_merge_commit(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeCommit",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_merge_commit(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_merge_conflicts(destination_commit_specifier, merge_option, repository_name, source_commit_specifier)
get_merge_conflicts(destination_commit_specifier, merge_option, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Returns information about merge conflicts between the before and after commit IDs for a
pull request in a repository.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `merge_option`: The merge option or strategy you want to use to merge the code.
- `repository_name`: The name of the repository where the pull request was created.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"maxConflictFiles"`: The maximum number of files to include in the output.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function get_merge_conflicts(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeConflicts",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_merge_conflicts(
destinationCommitSpecifier,
mergeOption,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeConflicts",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"mergeOption" => mergeOption,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_merge_options(destination_commit_specifier, repository_name, source_commit_specifier)
get_merge_options(destination_commit_specifier, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Returns information about the merge options available for merging two specified branches.
For details about why a merge option is not available, use GetMergeConflicts or
DescribeMergeConflicts.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `repository_name`: The name of the repository that contains the commits about which you
want to get merge options.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
"""
function get_merge_options(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeOptions",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_merge_options(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetMergeOptions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pull_request(pull_request_id)
get_pull_request(pull_request_id, params::Dict{String,<:Any})
Gets information about a pull request in a specified repository.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
"""
function get_pull_request(pullRequestId; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"GetPullRequest",
Dict{String,Any}("pullRequestId" => pullRequestId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pull_request(
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetPullRequest",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pullRequestId" => pullRequestId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pull_request_approval_states(pull_request_id, revision_id)
get_pull_request_approval_states(pull_request_id, revision_id, params::Dict{String,<:Any})
Gets information about the approval states for a specified pull request. Approval states
only apply to pull requests that have one or more approval rules applied to them.
# Arguments
- `pull_request_id`: The system-generated ID for the pull request.
- `revision_id`: The system-generated ID for the pull request revision.
"""
function get_pull_request_approval_states(
pullRequestId, revisionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetPullRequestApprovalStates",
Dict{String,Any}("pullRequestId" => pullRequestId, "revisionId" => revisionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pull_request_approval_states(
pullRequestId,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetPullRequestApprovalStates",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "revisionId" => revisionId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pull_request_override_state(pull_request_id, revision_id)
get_pull_request_override_state(pull_request_id, revision_id, params::Dict{String,<:Any})
Returns information about whether approval rules have been set aside (overridden) for a
pull request, and if so, the Amazon Resource Name (ARN) of the user or identity that
overrode the rules and their requirements for the pull request.
# Arguments
- `pull_request_id`: The ID of the pull request for which you want to get information about
whether approval rules have been set aside (overridden).
- `revision_id`: The system-generated ID of the revision for the pull request. To retrieve
the most recent revision ID, use GetPullRequest.
"""
function get_pull_request_override_state(
pullRequestId, revisionId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetPullRequestOverrideState",
Dict{String,Any}("pullRequestId" => pullRequestId, "revisionId" => revisionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pull_request_override_state(
pullRequestId,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetPullRequestOverrideState",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "revisionId" => revisionId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository(repository_name)
get_repository(repository_name, params::Dict{String,<:Any})
Returns information about a repository. The description field for a repository accepts all
HTML characters and all valid Unicode characters. Applications that do not HTML-encode the
description and display it in a webpage can expose users to potentially malicious code.
Make sure that you HTML-encode the description field in any application that uses this API
to display the repository description on a webpage.
# Arguments
- `repository_name`: The name of the repository to get information about.
"""
function get_repository(repositoryName; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"GetRepository",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetRepository",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository_triggers(repository_name)
get_repository_triggers(repository_name, params::Dict{String,<:Any})
Gets information about triggers configured for a repository.
# Arguments
- `repository_name`: The name of the repository for which the trigger is configured.
"""
function get_repository_triggers(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"GetRepositoryTriggers",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository_triggers(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"GetRepositoryTriggers",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_approval_rule_templates()
list_approval_rule_templates(params::Dict{String,<:Any})
Lists all approval rule templates in the specified Amazon Web Services Region in your
Amazon Web Services account. If an Amazon Web Services Region is not specified, the Amazon
Web Services Region where you are signed in is used.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function list_approval_rule_templates(; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"ListApprovalRuleTemplates"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_approval_rule_templates(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListApprovalRuleTemplates",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_associated_approval_rule_templates_for_repository(repository_name)
list_associated_approval_rule_templates_for_repository(repository_name, params::Dict{String,<:Any})
Lists all approval rule templates that are associated with a specified repository.
# Arguments
- `repository_name`: The name of the repository for which you want to list all associated
approval rule templates.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function list_associated_approval_rule_templates_for_repository(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListAssociatedApprovalRuleTemplatesForRepository",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_associated_approval_rule_templates_for_repository(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListAssociatedApprovalRuleTemplatesForRepository",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_branches(repository_name)
list_branches(repository_name, params::Dict{String,<:Any})
Gets information about one or more branches in a repository.
# Arguments
- `repository_name`: The name of the repository that contains the branches.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An enumeration token that allows the operation to batch the results.
"""
function list_branches(repositoryName; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"ListBranches",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_branches(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListBranches",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_file_commit_history(file_path, repository_name)
list_file_commit_history(file_path, repository_name, params::Dict{String,<:Any})
Retrieves a list of commits and changes to a specified file.
# Arguments
- `file_path`: The full path of the file whose history you want to retrieve, including the
name of the file.
- `repository_name`: The name of the repository that contains the file.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitSpecifier"`: The fully quaified reference that identifies the commit that
contains the file. For example, you can specify a full commit ID, a tag, a branch name, or
a reference such as refs/heads/main. If none is provided, the head commit is used.
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"nextToken"`: An enumeration token that allows the operation to batch the results.
"""
function list_file_commit_history(
filePath, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListFileCommitHistory",
Dict{String,Any}("filePath" => filePath, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_file_commit_history(
filePath,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListFileCommitHistory",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"filePath" => filePath, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pull_requests(repository_name)
list_pull_requests(repository_name, params::Dict{String,<:Any})
Returns a list of pull requests for a specified repository. The return list can be refined
by pull request status or pull request author ARN.
# Arguments
- `repository_name`: The name of the repository for which you want to list pull requests.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorArn"`: Optional. The Amazon Resource Name (ARN) of the user who created the pull
request. If used, this filters the results to pull requests created by that user.
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
- `"pullRequestStatus"`: Optional. The status of the pull request. If used, this refines
the results to the pull requests that match the specified status.
"""
function list_pull_requests(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListPullRequests",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pull_requests(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListPullRequests",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_repositories()
list_repositories(params::Dict{String,<:Any})
Gets information about one or more repositories.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An enumeration token that allows the operation to batch the results of the
operation. Batch sizes are 1,000 for list repository operations. When the client sends the
token back to CodeCommit, another page of 1,000 records is retrieved.
- `"order"`: The order in which to sort the results of a list repositories operation.
- `"sortBy"`: The criteria used to sort the results of a list repositories operation.
"""
function list_repositories(; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"ListRepositories"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_repositories(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListRepositories", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_repositories_for_approval_rule_template(approval_rule_template_name)
list_repositories_for_approval_rule_template(approval_rule_template_name, params::Dict{String,<:Any})
Lists all repositories associated with the specified approval rule template.
# Arguments
- `approval_rule_template_name`: The name of the approval rule template for which you want
to list repositories that are associated with that template.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function list_repositories_for_approval_rule_template(
approvalRuleTemplateName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListRepositoriesForApprovalRuleTemplate",
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_repositories_for_approval_rule_template(
approvalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListRepositoriesForApprovalRuleTemplate",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("approvalRuleTemplateName" => approvalRuleTemplateName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Gets information about Amazon Web Servicestags for a specified Amazon Resource Name (ARN)
in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and
Operations in the CodeCommit User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource for which you want to get
information about tags, if any.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"ListTagsForResource",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_branches_by_fast_forward(destination_commit_specifier, repository_name, source_commit_specifier)
merge_branches_by_fast_forward(destination_commit_specifier, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Merges two branches using the fast-forward merge strategy.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `repository_name`: The name of the repository where you want to merge two branches.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"targetBranch"`: The branch where the merge is applied.
"""
function merge_branches_by_fast_forward(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesByFastForward",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_branches_by_fast_forward(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesByFastForward",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_branches_by_squash(destination_commit_specifier, repository_name, source_commit_specifier)
merge_branches_by_squash(destination_commit_specifier, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Merges two branches using the squash merge strategy.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `repository_name`: The name of the repository where you want to merge two branches.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the commit. This information is used
as both the author and committer for the commit.
- `"commitMessage"`: The commit message for the merge.
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolution"`: If AUTOMERGE is the conflict resolution strategy, a list of
inputs to use when resolving conflicts during a merge.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"email"`: The email address of the person merging the branches. This information is used
in the commit information for the merge.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If this is specified as true, a
.gitkeep file is created for empty folders. The default is false.
- `"targetBranch"`: The branch where the merge is applied.
"""
function merge_branches_by_squash(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesBySquash",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_branches_by_squash(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesBySquash",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_branches_by_three_way(destination_commit_specifier, repository_name, source_commit_specifier)
merge_branches_by_three_way(destination_commit_specifier, repository_name, source_commit_specifier, params::Dict{String,<:Any})
Merges two specified branches using the three-way merge strategy.
# Arguments
- `destination_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference
used to identify a commit (for example, a branch name or a full commit ID).
- `repository_name`: The name of the repository where you want to merge two branches.
- `source_commit_specifier`: The branch, tag, HEAD, or other fully qualified reference used
to identify a commit (for example, a branch name or a full commit ID).
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the commit. This information is used
as both the author and committer for the commit.
- `"commitMessage"`: The commit message to include in the commit information for the merge.
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolution"`: If AUTOMERGE is the conflict resolution strategy, a list of
inputs to use when resolving conflicts during a merge.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"email"`: The email address of the person merging the branches. This information is used
in the commit information for the merge.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If true, a .gitkeep file is
created for empty folders. The default is false.
- `"targetBranch"`: The branch where the merge is applied.
"""
function merge_branches_by_three_way(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesByThreeWay",
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_branches_by_three_way(
destinationCommitSpecifier,
repositoryName,
sourceCommitSpecifier,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergeBranchesByThreeWay",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"destinationCommitSpecifier" => destinationCommitSpecifier,
"repositoryName" => repositoryName,
"sourceCommitSpecifier" => sourceCommitSpecifier,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_pull_request_by_fast_forward(pull_request_id, repository_name)
merge_pull_request_by_fast_forward(pull_request_id, repository_name, params::Dict{String,<:Any})
Attempts to merge the source commit of a pull request into the specified destination branch
for that pull request at the specified commit using the fast-forward merge strategy. If the
merge is successful, it closes the pull request.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `repository_name`: The name of the repository where the pull request was created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"sourceCommitId"`: The full commit ID of the original or updated commit in the pull
request source branch. Pass this value if you want an exception thrown if the current
commit ID of the tip of the source branch does not match this commit ID.
"""
function merge_pull_request_by_fast_forward(
pullRequestId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"MergePullRequestByFastForward",
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_pull_request_by_fast_forward(
pullRequestId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergePullRequestByFastForward",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_pull_request_by_squash(pull_request_id, repository_name)
merge_pull_request_by_squash(pull_request_id, repository_name, params::Dict{String,<:Any})
Attempts to merge the source commit of a pull request into the specified destination branch
for that pull request at the specified commit using the squash merge strategy. If the merge
is successful, it closes the pull request.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `repository_name`: The name of the repository where the pull request was created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the commit. This information is used
as both the author and committer for the commit.
- `"commitMessage"`: The commit message to include in the commit information for the merge.
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolution"`: If AUTOMERGE is the conflict resolution strategy, a list of
inputs to use when resolving conflicts during a merge.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"email"`: The email address of the person merging the branches. This information is used
in the commit information for the merge.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If true, a .gitkeep file is
created for empty folders. The default is false.
- `"sourceCommitId"`: The full commit ID of the original or updated commit in the pull
request source branch. Pass this value if you want an exception thrown if the current
commit ID of the tip of the source branch does not match this commit ID.
"""
function merge_pull_request_by_squash(
pullRequestId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"MergePullRequestBySquash",
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_pull_request_by_squash(
pullRequestId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergePullRequestBySquash",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
merge_pull_request_by_three_way(pull_request_id, repository_name)
merge_pull_request_by_three_way(pull_request_id, repository_name, params::Dict{String,<:Any})
Attempts to merge the source commit of a pull request into the specified destination branch
for that pull request at the specified commit using the three-way merge strategy. If the
merge is successful, it closes the pull request.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `repository_name`: The name of the repository where the pull request was created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"authorName"`: The name of the author who created the commit. This information is used
as both the author and committer for the commit.
- `"commitMessage"`: The commit message to include in the commit information for the merge.
- `"conflictDetailLevel"`: The level of conflict detail to use. If unspecified, the default
FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences
in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the
same file in both branches has differences on the same line.
- `"conflictResolution"`: If AUTOMERGE is the conflict resolution strategy, a list of
inputs to use when resolving conflicts during a merge.
- `"conflictResolutionStrategy"`: Specifies which branch to use when resolving conflicts,
or whether to attempt automatically merging two versions of a file. The default is NONE,
which requires any conflicts to be resolved manually before the merge operation is
successful.
- `"email"`: The email address of the person merging the branches. This information is used
in the commit information for the merge.
- `"keepEmptyFolders"`: If the commit contains deletions, whether to keep a folder or
folder structure if the changes leave the folders empty. If true, a .gitkeep file is
created for empty folders. The default is false.
- `"sourceCommitId"`: The full commit ID of the original or updated commit in the pull
request source branch. Pass this value if you want an exception thrown if the current
commit ID of the tip of the source branch does not match this commit ID.
"""
function merge_pull_request_by_three_way(
pullRequestId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"MergePullRequestByThreeWay",
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function merge_pull_request_by_three_way(
pullRequestId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"MergePullRequestByThreeWay",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
override_pull_request_approval_rules(override_status, pull_request_id, revision_id)
override_pull_request_approval_rules(override_status, pull_request_id, revision_id, params::Dict{String,<:Any})
Sets aside (overrides) all approval rule requirements for a specified pull request.
# Arguments
- `override_status`: Whether you want to set aside approval rule requirements for the pull
request (OVERRIDE) or revoke a previous override and apply approval rule requirements
(REVOKE). REVOKE status is not stored.
- `pull_request_id`: The system-generated ID of the pull request for which you want to
override all approval rule requirements. To get this information, use GetPullRequest.
- `revision_id`: The system-generated ID of the most recent revision of the pull request.
You cannot override approval rules for anything but the most recent revision of a pull
request. To get the revision ID, use GetPullRequest.
"""
function override_pull_request_approval_rules(
overrideStatus,
pullRequestId,
revisionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"OverridePullRequestApprovalRules",
Dict{String,Any}(
"overrideStatus" => overrideStatus,
"pullRequestId" => pullRequestId,
"revisionId" => revisionId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function override_pull_request_approval_rules(
overrideStatus,
pullRequestId,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"OverridePullRequestApprovalRules",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"overrideStatus" => overrideStatus,
"pullRequestId" => pullRequestId,
"revisionId" => revisionId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
post_comment_for_compared_commit(after_commit_id, content, repository_name)
post_comment_for_compared_commit(after_commit_id, content, repository_name, params::Dict{String,<:Any})
Posts a comment on the comparison between two commits.
# Arguments
- `after_commit_id`: To establish the directionality of the comparison, the full commit ID
of the after commit.
- `content`: The content of the comment you want to make.
- `repository_name`: The name of the repository where you want to post a comment on the
comparison between commits.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"beforeCommitId"`: To establish the directionality of the comparison, the full commit ID
of the before commit. Required for commenting on any commit unless that commit is the
initial commit.
- `"clientRequestToken"`: A unique, client-generated idempotency token that, when provided
in a request, ensures the request cannot be repeated with a changed parameter. If a request
is received with the same parameters and a token is included, the request returns
information about the initial request that used that token.
- `"location"`: The location of the comparison where you want to comment.
"""
function post_comment_for_compared_commit(
afterCommitId,
content,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PostCommentForComparedCommit",
Dict{String,Any}(
"afterCommitId" => afterCommitId,
"content" => content,
"repositoryName" => repositoryName,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function post_comment_for_compared_commit(
afterCommitId,
content,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PostCommentForComparedCommit",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"afterCommitId" => afterCommitId,
"content" => content,
"repositoryName" => repositoryName,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
post_comment_for_pull_request(after_commit_id, before_commit_id, content, pull_request_id, repository_name)
post_comment_for_pull_request(after_commit_id, before_commit_id, content, pull_request_id, repository_name, params::Dict{String,<:Any})
Posts a comment on a pull request.
# Arguments
- `after_commit_id`: The full commit ID of the commit in the source branch that is the
current tip of the branch for the pull request when you post the comment.
- `before_commit_id`: The full commit ID of the commit in the destination branch that was
the tip of the branch at the time the pull request was created.
- `content`: The content of your comment on the change.
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `repository_name`: The name of the repository where you want to post a comment on a pull
request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, client-generated idempotency token that, when provided
in a request, ensures the request cannot be repeated with a changed parameter. If a request
is received with the same parameters and a token is included, the request returns
information about the initial request that used that token.
- `"location"`: The location of the change where you want to post your comment. If no
location is provided, the comment is posted as a general comment on the pull request
difference between the before commit ID and the after commit ID.
"""
function post_comment_for_pull_request(
afterCommitId,
beforeCommitId,
content,
pullRequestId,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PostCommentForPullRequest",
Dict{String,Any}(
"afterCommitId" => afterCommitId,
"beforeCommitId" => beforeCommitId,
"content" => content,
"pullRequestId" => pullRequestId,
"repositoryName" => repositoryName,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function post_comment_for_pull_request(
afterCommitId,
beforeCommitId,
content,
pullRequestId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PostCommentForPullRequest",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"afterCommitId" => afterCommitId,
"beforeCommitId" => beforeCommitId,
"content" => content,
"pullRequestId" => pullRequestId,
"repositoryName" => repositoryName,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
post_comment_reply(content, in_reply_to)
post_comment_reply(content, in_reply_to, params::Dict{String,<:Any})
Posts a comment in reply to an existing comment on a comparison between commits or a pull
request.
# Arguments
- `content`: The contents of your reply to a comment.
- `in_reply_to`: The system-generated ID of the comment to which you want to reply. To get
this ID, use GetCommentsForComparedCommit or GetCommentsForPullRequest.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: A unique, client-generated idempotency token that, when provided
in a request, ensures the request cannot be repeated with a changed parameter. If a request
is received with the same parameters and a token is included, the request returns
information about the initial request that used that token.
"""
function post_comment_reply(
content, inReplyTo; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"PostCommentReply",
Dict{String,Any}(
"content" => content,
"inReplyTo" => inReplyTo,
"clientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function post_comment_reply(
content,
inReplyTo,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PostCommentReply",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"content" => content,
"inReplyTo" => inReplyTo,
"clientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_comment_reaction(comment_id, reaction_value)
put_comment_reaction(comment_id, reaction_value, params::Dict{String,<:Any})
Adds or updates a reaction to a specified comment for the user whose identity is used to
make the request. You can only add or update a reaction for yourself. You cannot add,
modify, or delete a reaction for another user.
# Arguments
- `comment_id`: The ID of the comment to which you want to add or update a reaction.
- `reaction_value`: The emoji reaction you want to add or update. To remove a reaction,
provide a value of blank or null. You can also provide the value of none. For information
about emoji reaction values supported in CodeCommit, see the CodeCommit User Guide.
"""
function put_comment_reaction(
commentId, reactionValue; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"PutCommentReaction",
Dict{String,Any}("commentId" => commentId, "reactionValue" => reactionValue);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_comment_reaction(
commentId,
reactionValue,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PutCommentReaction",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"commentId" => commentId, "reactionValue" => reactionValue
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_file(branch_name, file_content, file_path, repository_name)
put_file(branch_name, file_content, file_path, repository_name, params::Dict{String,<:Any})
Adds or updates a file in a branch in an CodeCommit repository, and generates a commit for
the addition in the specified branch.
# Arguments
- `branch_name`: The name of the branch where you want to add or update the file. If this
is an empty repository, this branch is created.
- `file_content`: The content of the file, in binary object format.
- `file_path`: The name of the file you want to add or update, including the relative path
to the file in the repository. If the path does not currently exist in the repository, the
path is created as part of adding the file.
- `repository_name`: The name of the repository where you want to add or update the file.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"commitMessage"`: A message about why this file was added or updated. Although it is
optional, a message makes the commit history for your repository more useful.
- `"email"`: An email address for the person adding or updating the file.
- `"fileMode"`: The file mode permissions of the blob. Valid file mode permissions are
listed here.
- `"name"`: The name of the person adding or updating the file. Although it is optional, a
name makes the commit history for your repository more useful.
- `"parentCommitId"`: The full commit ID of the head commit in the branch where you want to
add or update the file. If this is an empty repository, no commit ID is required. If this
is not an empty repository, a commit ID is required. The commit ID must match the ID of
the head commit at the time of the operation. Otherwise, an error occurs, and the file is
not added or updated.
"""
function put_file(
branchName,
fileContent,
filePath,
repositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PutFile",
Dict{String,Any}(
"branchName" => branchName,
"fileContent" => fileContent,
"filePath" => filePath,
"repositoryName" => repositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_file(
branchName,
fileContent,
filePath,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PutFile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"branchName" => branchName,
"fileContent" => fileContent,
"filePath" => filePath,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_repository_triggers(repository_name, triggers)
put_repository_triggers(repository_name, triggers, params::Dict{String,<:Any})
Replaces all triggers for a repository. Used to create or delete triggers.
# Arguments
- `repository_name`: The name of the repository where you want to create or update the
trigger.
- `triggers`: The JSON block of configuration information for each trigger.
"""
function put_repository_triggers(
repositoryName, triggers; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"PutRepositoryTriggers",
Dict{String,Any}("repositoryName" => repositoryName, "triggers" => triggers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_repository_triggers(
repositoryName,
triggers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"PutRepositoryTriggers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"repositoryName" => repositoryName, "triggers" => triggers
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds or updates tags for a resource in CodeCommit. For a list of valid resources in
CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to which you want to add
or update tags.
- `tags`: The key-value pair to use when tagging this repository.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return codecommit(
"TagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
test_repository_triggers(repository_name, triggers)
test_repository_triggers(repository_name, triggers, params::Dict{String,<:Any})
Tests the functionality of repository triggers by sending information to the trigger
target. If real data is available in the repository, the test sends data from the last
commit. If no data is available, sample data is generated.
# Arguments
- `repository_name`: The name of the repository in which to test the triggers.
- `triggers`: The list of triggers to test.
"""
function test_repository_triggers(
repositoryName, triggers; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"TestRepositoryTriggers",
Dict{String,Any}("repositoryName" => repositoryName, "triggers" => triggers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function test_repository_triggers(
repositoryName,
triggers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"TestRepositoryTriggers",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"repositoryName" => repositoryName, "triggers" => triggers
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags for a resource in CodeCommit. For a list of valid resources in CodeCommit, see
CodeCommit Resources and Operations in the CodeCommit User Guide.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to which you want to
remove tags.
- `tag_keys`: The tag key for each tag that you want to remove from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UntagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_approval_rule_template_content(approval_rule_template_name, new_rule_content)
update_approval_rule_template_content(approval_rule_template_name, new_rule_content, params::Dict{String,<:Any})
Updates the content of an approval rule template. You can change the number of required
approvals, the membership of the approval rule, and whether an approval pool is defined.
# Arguments
- `approval_rule_template_name`: The name of the approval rule template where you want to
update the content of the rule.
- `new_rule_content`: The content that replaces the existing content of the rule. Content
statements must be complete. You cannot provide only the changes.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"existingRuleContentSha256"`: The SHA-256 hash signature for the content of the approval
rule. You can retrieve this information by using GetPullRequest.
"""
function update_approval_rule_template_content(
approvalRuleTemplateName,
newRuleContent;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateContent",
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"newRuleContent" => newRuleContent,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_approval_rule_template_content(
approvalRuleTemplateName,
newRuleContent,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateContent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateName" => approvalRuleTemplateName,
"newRuleContent" => newRuleContent,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_approval_rule_template_description(approval_rule_template_description, approval_rule_template_name)
update_approval_rule_template_description(approval_rule_template_description, approval_rule_template_name, params::Dict{String,<:Any})
Updates the description for a specified approval rule template.
# Arguments
- `approval_rule_template_description`: The updated description of the approval rule
template.
- `approval_rule_template_name`: The name of the template for which you want to update the
description.
"""
function update_approval_rule_template_description(
approvalRuleTemplateDescription,
approvalRuleTemplateName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateDescription",
Dict{String,Any}(
"approvalRuleTemplateDescription" => approvalRuleTemplateDescription,
"approvalRuleTemplateName" => approvalRuleTemplateName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_approval_rule_template_description(
approvalRuleTemplateDescription,
approvalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateDescription",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleTemplateDescription" => approvalRuleTemplateDescription,
"approvalRuleTemplateName" => approvalRuleTemplateName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_approval_rule_template_name(new_approval_rule_template_name, old_approval_rule_template_name)
update_approval_rule_template_name(new_approval_rule_template_name, old_approval_rule_template_name, params::Dict{String,<:Any})
Updates the name of a specified approval rule template.
# Arguments
- `new_approval_rule_template_name`: The new name you want to apply to the approval rule
template.
- `old_approval_rule_template_name`: The current name of the approval rule template.
"""
function update_approval_rule_template_name(
newApprovalRuleTemplateName,
oldApprovalRuleTemplateName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateName",
Dict{String,Any}(
"newApprovalRuleTemplateName" => newApprovalRuleTemplateName,
"oldApprovalRuleTemplateName" => oldApprovalRuleTemplateName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_approval_rule_template_name(
newApprovalRuleTemplateName,
oldApprovalRuleTemplateName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateApprovalRuleTemplateName",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"newApprovalRuleTemplateName" => newApprovalRuleTemplateName,
"oldApprovalRuleTemplateName" => oldApprovalRuleTemplateName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_comment(comment_id, content)
update_comment(comment_id, content, params::Dict{String,<:Any})
Replaces the contents of a comment.
# Arguments
- `comment_id`: The system-generated ID of the comment you want to update. To get this ID,
use GetCommentsForComparedCommit or GetCommentsForPullRequest.
- `content`: The updated content to replace the existing content of the comment.
"""
function update_comment(
commentId, content; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdateComment",
Dict{String,Any}("commentId" => commentId, "content" => content);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_comment(
commentId,
content,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateComment",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("commentId" => commentId, "content" => content),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_default_branch(default_branch_name, repository_name)
update_default_branch(default_branch_name, repository_name, params::Dict{String,<:Any})
Sets or changes the default branch name for the specified repository. If you use this
operation to change the default branch name to the current default branch name, a success
message is returned even though the default branch did not change.
# Arguments
- `default_branch_name`: The name of the branch to set as the default branch.
- `repository_name`: The name of the repository for which you want to set or change the
default branch.
"""
function update_default_branch(
defaultBranchName, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdateDefaultBranch",
Dict{String,Any}(
"defaultBranchName" => defaultBranchName, "repositoryName" => repositoryName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_default_branch(
defaultBranchName,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateDefaultBranch",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"defaultBranchName" => defaultBranchName,
"repositoryName" => repositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pull_request_approval_rule_content(approval_rule_name, new_rule_content, pull_request_id)
update_pull_request_approval_rule_content(approval_rule_name, new_rule_content, pull_request_id, params::Dict{String,<:Any})
Updates the structure of an approval rule created specifically for a pull request. For
example, you can change the number of required approvers and the approval pool for
approvers.
# Arguments
- `approval_rule_name`: The name of the approval rule you want to update.
- `new_rule_content`: The updated content for the approval rule. When you update the
content of the approval rule, you can specify approvers in an approval pool in one of two
ways: CodeCommitApprovers: This option only requires an Amazon Web Services account and
a resource. It can be used for both IAM users and federated access users whose name matches
the provided resource name. This is a very powerful option that offers a great deal of
flexibility. For example, if you specify the Amazon Web Services account 123456789012 and
Mary_Major, all of the following are counted as approvals coming from that user: An IAM
user in the account (arn:aws:iam::123456789012:user/Mary_Major) A federated user
identified in IAM as Mary_Major (arn:aws:sts::123456789012:federated-user/Mary_Major)
This option does not recognize an active session of someone assuming the role of
CodeCommitReview with a role session name of Mary_Major
(arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you include a
wildcard (*Mary_Major). Fully qualified ARN: This option allows you to specify the fully
qualified Amazon Resource Name (ARN) of the IAM user or role. For more information about
IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User Guide.
- `pull_request_id`: The system-generated ID of the pull request.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"existingRuleContentSha256"`: The SHA-256 hash signature for the content of the approval
rule. You can retrieve this information by using GetPullRequest.
"""
function update_pull_request_approval_rule_content(
approvalRuleName,
newRuleContent,
pullRequestId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestApprovalRuleContent",
Dict{String,Any}(
"approvalRuleName" => approvalRuleName,
"newRuleContent" => newRuleContent,
"pullRequestId" => pullRequestId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pull_request_approval_rule_content(
approvalRuleName,
newRuleContent,
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestApprovalRuleContent",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalRuleName" => approvalRuleName,
"newRuleContent" => newRuleContent,
"pullRequestId" => pullRequestId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pull_request_approval_state(approval_state, pull_request_id, revision_id)
update_pull_request_approval_state(approval_state, pull_request_id, revision_id, params::Dict{String,<:Any})
Updates the state of a user's approval on a pull request. The user is derived from the
signed-in account when the request is made.
# Arguments
- `approval_state`: The approval state to associate with the user on the pull request.
- `pull_request_id`: The system-generated ID of the pull request.
- `revision_id`: The system-generated ID of the revision.
"""
function update_pull_request_approval_state(
approvalState,
pullRequestId,
revisionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestApprovalState",
Dict{String,Any}(
"approvalState" => approvalState,
"pullRequestId" => pullRequestId,
"revisionId" => revisionId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pull_request_approval_state(
approvalState,
pullRequestId,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestApprovalState",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"approvalState" => approvalState,
"pullRequestId" => pullRequestId,
"revisionId" => revisionId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pull_request_description(description, pull_request_id)
update_pull_request_description(description, pull_request_id, params::Dict{String,<:Any})
Replaces the contents of the description of a pull request.
# Arguments
- `description`: The updated content of the description for the pull request. This content
replaces the existing description.
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
"""
function update_pull_request_description(
description, pullRequestId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdatePullRequestDescription",
Dict{String,Any}("description" => description, "pullRequestId" => pullRequestId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pull_request_description(
description,
pullRequestId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestDescription",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"description" => description, "pullRequestId" => pullRequestId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pull_request_status(pull_request_id, pull_request_status)
update_pull_request_status(pull_request_id, pull_request_status, params::Dict{String,<:Any})
Updates the status of a pull request.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `pull_request_status`: The status of the pull request. The only valid operations are to
update the status from OPEN to OPEN, OPEN to CLOSED or from CLOSED to CLOSED.
"""
function update_pull_request_status(
pullRequestId, pullRequestStatus; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdatePullRequestStatus",
Dict{String,Any}(
"pullRequestId" => pullRequestId, "pullRequestStatus" => pullRequestStatus
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pull_request_status(
pullRequestId,
pullRequestStatus,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestStatus",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pullRequestId" => pullRequestId,
"pullRequestStatus" => pullRequestStatus,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pull_request_title(pull_request_id, title)
update_pull_request_title(pull_request_id, title, params::Dict{String,<:Any})
Replaces the title of a pull request.
# Arguments
- `pull_request_id`: The system-generated ID of the pull request. To get this ID, use
ListPullRequests.
- `title`: The updated title of the pull request. This replaces the existing title.
"""
function update_pull_request_title(
pullRequestId, title; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdatePullRequestTitle",
Dict{String,Any}("pullRequestId" => pullRequestId, "title" => title);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pull_request_title(
pullRequestId,
title,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdatePullRequestTitle",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("pullRequestId" => pullRequestId, "title" => title),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_repository_description(repository_name)
update_repository_description(repository_name, params::Dict{String,<:Any})
Sets or changes the comment or description for a repository. The description field for a
repository accepts all HTML characters and all valid Unicode characters. Applications that
do not HTML-encode the description and display it in a webpage can expose users to
potentially malicious code. Make sure that you HTML-encode the description field in any
application that uses this API to display the repository description on a webpage.
# Arguments
- `repository_name`: The name of the repository to set or change the comment or description
for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"repositoryDescription"`: The new comment or description for the specified repository.
Repository descriptions are limited to 1,000 characters.
"""
function update_repository_description(
repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdateRepositoryDescription",
Dict{String,Any}("repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_repository_description(
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateRepositoryDescription",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("repositoryName" => repositoryName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_repository_encryption_key(kms_key_id, repository_name)
update_repository_encryption_key(kms_key_id, repository_name, params::Dict{String,<:Any})
Updates the Key Management Service encryption key used to encrypt and decrypt a CodeCommit
repository.
# Arguments
- `kms_key_id`: The ID of the encryption key. You can view the ID of an encryption key in
the KMS console, or use the KMS APIs to programmatically retrieve a key ID. For more
information about acceptable values for keyID, see KeyId in the Decrypt API description in
the Key Management Service API Reference.
- `repository_name`: The name of the repository for which you want to update the KMS
encryption key used to encrypt and decrypt the repository.
"""
function update_repository_encryption_key(
kmsKeyId, repositoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdateRepositoryEncryptionKey",
Dict{String,Any}("kmsKeyId" => kmsKeyId, "repositoryName" => repositoryName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_repository_encryption_key(
kmsKeyId,
repositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateRepositoryEncryptionKey",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"kmsKeyId" => kmsKeyId, "repositoryName" => repositoryName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_repository_name(new_name, old_name)
update_repository_name(new_name, old_name, params::Dict{String,<:Any})
Renames a repository. The repository name must be unique across the calling Amazon Web
Services account. Repository names are limited to 100 alphanumeric, dash, and underscore
characters, and cannot include certain characters. The suffix .git is prohibited. For more
information about the limits on repository names, see Quotas in the CodeCommit User Guide.
# Arguments
- `new_name`: The new name for the repository.
- `old_name`: The current name of the repository.
"""
function update_repository_name(
newName, oldName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codecommit(
"UpdateRepositoryName",
Dict{String,Any}("newName" => newName, "oldName" => oldName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_repository_name(
newName,
oldName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codecommit(
"UpdateRepositoryName",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("newName" => newName, "oldName" => oldName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 38281 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codeconnections
using AWS.Compat
using AWS.UUIDs
"""
create_connection(connection_name)
create_connection(connection_name, params::Dict{String,<:Any})
Creates a connection that can then be given to other Amazon Web Services services like
CodePipeline so that it can access third-party code repositories. The connection is in
pending status until the third-party connection handshake is completed from the console.
# Arguments
- `connection_name`: The name of the connection to be created.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"HostArn"`: The Amazon Resource Name (ARN) of the host associated with the connection to
be created.
- `"ProviderType"`: The name of the external provider where your third-party code
repository is configured.
- `"Tags"`: The key-value pair to use when tagging the resource.
"""
function create_connection(
ConnectionName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"CreateConnection",
Dict{String,Any}("ConnectionName" => ConnectionName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_connection(
ConnectionName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateConnection",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ConnectionName" => ConnectionName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_host(name, provider_endpoint, provider_type)
create_host(name, provider_endpoint, provider_type, params::Dict{String,<:Any})
Creates a resource that represents the infrastructure where a third-party provider is
installed. The host is used when you create connections to an installed third-party
provider type, such as GitHub Enterprise Server. You create one host for all connections to
that provider. A host created through the CLI or the SDK is in `PENDING` status by
default. You can make its status `AVAILABLE` by setting up the host in the console.
# Arguments
- `name`: The name of the host to be created.
- `provider_endpoint`: The endpoint of the infrastructure to be represented by the host
after it is created.
- `provider_type`: The name of the installed provider to be associated with your
connection. The host resource represents the infrastructure where your provider type is
installed. The valid provider type is GitHub Enterprise Server.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: Tags for the host to be created.
- `"VpcConfiguration"`: The VPC configuration to be provisioned for the host. A VPC must be
configured and the infrastructure to be represented by the host must already be connected
to the VPC.
"""
function create_host(
Name, ProviderEndpoint, ProviderType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"CreateHost",
Dict{String,Any}(
"Name" => Name,
"ProviderEndpoint" => ProviderEndpoint,
"ProviderType" => ProviderType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_host(
Name,
ProviderEndpoint,
ProviderType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateHost",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"ProviderEndpoint" => ProviderEndpoint,
"ProviderType" => ProviderType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_repository_link(connection_arn, owner_id, repository_name)
create_repository_link(connection_arn, owner_id, repository_name, params::Dict{String,<:Any})
Creates a link to a specified external Git repository. A repository link allows Git sync to
monitor and sync changes to files in a specified Git repository.
# Arguments
- `connection_arn`: The Amazon Resource Name (ARN) of the connection to be associated with
the repository link.
- `owner_id`: The owner ID for the repository associated with a specific sync
configuration, such as the owner ID in GitHub.
- `repository_name`: The name of the repository to be associated with the repository link.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"EncryptionKeyArn"`: The Amazon Resource Name (ARN) encryption key for the repository to
be associated with the repository link.
- `"Tags"`: The tags for the repository to be associated with the repository link.
"""
function create_repository_link(
ConnectionArn,
OwnerId,
RepositoryName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateRepositoryLink",
Dict{String,Any}(
"ConnectionArn" => ConnectionArn,
"OwnerId" => OwnerId,
"RepositoryName" => RepositoryName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_repository_link(
ConnectionArn,
OwnerId,
RepositoryName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateRepositoryLink",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"ConnectionArn" => ConnectionArn,
"OwnerId" => OwnerId,
"RepositoryName" => RepositoryName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_sync_configuration(branch, config_file, repository_link_id, resource_name, role_arn, sync_type)
create_sync_configuration(branch, config_file, repository_link_id, resource_name, role_arn, sync_type, params::Dict{String,<:Any})
Creates a sync configuration which allows Amazon Web Services to sync content from a Git
repository to update a specified Amazon Web Services resource. Parameters for the sync
configuration are determined by the sync type.
# Arguments
- `branch`: The branch in the repository from which changes will be synced.
- `config_file`: The file name of the configuration file that manages syncing between the
connection and the repository. This configuration file is stored in the repository.
- `repository_link_id`: The ID of the repository link created for the connection. A
repository link allows Git sync to monitor and sync changes to files in a specified Git
repository.
- `resource_name`: The name of the Amazon Web Services resource (for example, a
CloudFormation stack in the case of CFN_STACK_SYNC) that will be synchronized from the
linked repository.
- `role_arn`: The ARN of the IAM role that grants permission for Amazon Web Services to use
Git sync to update a given Amazon Web Services resource on your behalf.
- `sync_type`: The type of sync configuration.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PublishDeploymentStatus"`: Whether to enable or disable publishing of deployment status
to source providers.
- `"TriggerResourceUpdateOn"`: When to trigger Git sync to begin the stack update.
"""
function create_sync_configuration(
Branch,
ConfigFile,
RepositoryLinkId,
ResourceName,
RoleArn,
SyncType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateSyncConfiguration",
Dict{String,Any}(
"Branch" => Branch,
"ConfigFile" => ConfigFile,
"RepositoryLinkId" => RepositoryLinkId,
"ResourceName" => ResourceName,
"RoleArn" => RoleArn,
"SyncType" => SyncType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_sync_configuration(
Branch,
ConfigFile,
RepositoryLinkId,
ResourceName,
RoleArn,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"CreateSyncConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Branch" => Branch,
"ConfigFile" => ConfigFile,
"RepositoryLinkId" => RepositoryLinkId,
"ResourceName" => ResourceName,
"RoleArn" => RoleArn,
"SyncType" => SyncType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_connection(connection_arn)
delete_connection(connection_arn, params::Dict{String,<:Any})
The connection to be deleted.
# Arguments
- `connection_arn`: The Amazon Resource Name (ARN) of the connection to be deleted. The
ARN is never reused if the connection is deleted.
"""
function delete_connection(ConnectionArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"DeleteConnection",
Dict{String,Any}("ConnectionArn" => ConnectionArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_connection(
ConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"DeleteConnection",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ConnectionArn" => ConnectionArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_host(host_arn)
delete_host(host_arn, params::Dict{String,<:Any})
The host to be deleted. Before you delete a host, all connections associated to the host
must be deleted. A host cannot be deleted if it is in the VPC_CONFIG_INITIALIZING or
VPC_CONFIG_DELETING state.
# Arguments
- `host_arn`: The Amazon Resource Name (ARN) of the host to be deleted.
"""
function delete_host(HostArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"DeleteHost",
Dict{String,Any}("HostArn" => HostArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_host(
HostArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"DeleteHost",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HostArn" => HostArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_repository_link(repository_link_id)
delete_repository_link(repository_link_id, params::Dict{String,<:Any})
Deletes the association between your connection and a specified external Git repository.
# Arguments
- `repository_link_id`: The ID of the repository link to be deleted.
"""
function delete_repository_link(
RepositoryLinkId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"DeleteRepositoryLink",
Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_repository_link(
RepositoryLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"DeleteRepositoryLink",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_sync_configuration(resource_name, sync_type)
delete_sync_configuration(resource_name, sync_type, params::Dict{String,<:Any})
Deletes the sync configuration for a specified repository and connection.
# Arguments
- `resource_name`: The name of the Amazon Web Services resource associated with the sync
configuration to be deleted.
- `sync_type`: The type of sync configuration to be deleted.
"""
function delete_sync_configuration(
ResourceName, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"DeleteSyncConfiguration",
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_sync_configuration(
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"DeleteSyncConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_connection(connection_arn)
get_connection(connection_arn, params::Dict{String,<:Any})
Returns the connection ARN and details such as status, owner, and provider type.
# Arguments
- `connection_arn`: The Amazon Resource Name (ARN) of a connection.
"""
function get_connection(ConnectionArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"GetConnection",
Dict{String,Any}("ConnectionArn" => ConnectionArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_connection(
ConnectionArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetConnection",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ConnectionArn" => ConnectionArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_host(host_arn)
get_host(host_arn, params::Dict{String,<:Any})
Returns the host ARN and details such as status, provider type, endpoint, and, if
applicable, the VPC configuration.
# Arguments
- `host_arn`: The Amazon Resource Name (ARN) of the requested host.
"""
function get_host(HostArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"GetHost",
Dict{String,Any}("HostArn" => HostArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_host(
HostArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetHost",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HostArn" => HostArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository_link(repository_link_id)
get_repository_link(repository_link_id, params::Dict{String,<:Any})
Returns details about a repository link. A repository link allows Git sync to monitor and
sync changes from files in a specified Git repository.
# Arguments
- `repository_link_id`: The ID of the repository link to get.
"""
function get_repository_link(
RepositoryLinkId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetRepositoryLink",
Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository_link(
RepositoryLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetRepositoryLink",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_repository_sync_status(branch, repository_link_id, sync_type)
get_repository_sync_status(branch, repository_link_id, sync_type, params::Dict{String,<:Any})
Returns details about the sync status for a repository. A repository sync uses Git sync to
push and pull changes from your remote repository.
# Arguments
- `branch`: The branch of the repository link for the requested repository sync status.
- `repository_link_id`: The repository link ID for the requested repository sync status.
- `sync_type`: The sync type of the requested sync status.
"""
function get_repository_sync_status(
Branch, RepositoryLinkId, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetRepositorySyncStatus",
Dict{String,Any}(
"Branch" => Branch,
"RepositoryLinkId" => RepositoryLinkId,
"SyncType" => SyncType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_repository_sync_status(
Branch,
RepositoryLinkId,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetRepositorySyncStatus",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Branch" => Branch,
"RepositoryLinkId" => RepositoryLinkId,
"SyncType" => SyncType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_resource_sync_status(resource_name, sync_type)
get_resource_sync_status(resource_name, sync_type, params::Dict{String,<:Any})
Returns the status of the sync with the Git repository for a specific Amazon Web Services
resource.
# Arguments
- `resource_name`: The name of the Amazon Web Services resource for the sync status with
the Git repository.
- `sync_type`: The sync type for the sync status with the Git repository.
"""
function get_resource_sync_status(
ResourceName, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetResourceSyncStatus",
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_resource_sync_status(
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetResourceSyncStatus",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sync_blocker_summary(resource_name, sync_type)
get_sync_blocker_summary(resource_name, sync_type, params::Dict{String,<:Any})
Returns a list of the most recent sync blockers.
# Arguments
- `resource_name`: The name of the Amazon Web Services resource currently blocked from
automatically being synced from a Git repository.
- `sync_type`: The sync type for the sync blocker summary.
"""
function get_sync_blocker_summary(
ResourceName, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetSyncBlockerSummary",
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sync_blocker_summary(
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetSyncBlockerSummary",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_sync_configuration(resource_name, sync_type)
get_sync_configuration(resource_name, sync_type, params::Dict{String,<:Any})
Returns details about a sync configuration, including the sync type and resource name. A
sync configuration allows the configuration to sync (push and pull) changes from the remote
repository for a specified branch in a Git repository.
# Arguments
- `resource_name`: The name of the Amazon Web Services resource for the sync configuration
for which you want to retrieve information.
- `sync_type`: The sync type for the sync configuration for which you want to retrieve
information.
"""
function get_sync_configuration(
ResourceName, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"GetSyncConfiguration",
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_sync_configuration(
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"GetSyncConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_connections()
list_connections(params::Dict{String,<:Any})
Lists the connections associated with your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"HostArnFilter"`: Filters the list of connections to those associated with a specified
host.
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned nextToken value.
- `"NextToken"`: The token that was returned from the previous ListConnections call, which
can be used to return the next set of connections in the list.
- `"ProviderTypeFilter"`: Filters the list of connections to those associated with a
specified provider, such as Bitbucket.
"""
function list_connections(; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"ListConnections"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_connections(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListConnections", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_hosts()
list_hosts(params::Dict{String,<:Any})
Lists the hosts associated with your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned nextToken value.
- `"NextToken"`: The token that was returned from the previous ListHosts call, which can be
used to return the next set of hosts in the list.
"""
function list_hosts(; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"ListHosts"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_hosts(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListHosts", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_repository_links()
list_repository_links(params::Dict{String,<:Any})
Lists the repository links created for connections in your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"NextToken"`: An enumeration token that, when provided in a request, returns the next
batch of the results.
"""
function list_repository_links(; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"ListRepositoryLinks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_repository_links(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListRepositoryLinks",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_repository_sync_definitions(repository_link_id, sync_type)
list_repository_sync_definitions(repository_link_id, sync_type, params::Dict{String,<:Any})
Lists the repository sync definitions for repository links in your account.
# Arguments
- `repository_link_id`: The ID of the repository link for the sync definition for which you
want to retrieve information.
- `sync_type`: The sync type of the repository link for the the sync definition for which
you want to retrieve information.
"""
function list_repository_sync_definitions(
RepositoryLinkId, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListRepositorySyncDefinitions",
Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_repository_sync_definitions(
RepositoryLinkId,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"ListRepositorySyncDefinitions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"RepositoryLinkId" => RepositoryLinkId, "SyncType" => SyncType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_sync_configurations(repository_link_id, sync_type)
list_sync_configurations(repository_link_id, sync_type, params::Dict{String,<:Any})
Returns a list of sync configurations for a specified repository.
# Arguments
- `repository_link_id`: The ID of the repository link for the requested list of sync
configurations.
- `sync_type`: The sync type for the requested list of sync configurations.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: A non-zero, non-negative integer used to limit the number of returned
results.
- `"NextToken"`: An enumeration token that allows the operation to batch the results of the
operation.
"""
function list_sync_configurations(
RepositoryLinkId, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListSyncConfigurations",
Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_sync_configurations(
RepositoryLinkId,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"ListSyncConfigurations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"RepositoryLinkId" => RepositoryLinkId, "SyncType" => SyncType
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Gets the set of key-value pairs (metadata) that are used to manage the resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource for which you want to get
information about tags, if any.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds to or modifies the tags of the given resource. Tags are metadata that can be used to
manage a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to which you want to add
or update tags.
- `tags`: The tags you want to modify or add to the resource.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"TagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from an Amazon Web Services resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to remove tags from.
- `tag_keys`: The list of keys for the tags to be removed from the resource.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"UntagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_host(host_arn)
update_host(host_arn, params::Dict{String,<:Any})
Updates a specified host with the provided configurations.
# Arguments
- `host_arn`: The Amazon Resource Name (ARN) of the host to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ProviderEndpoint"`: The URL or endpoint of the host to be updated.
- `"VpcConfiguration"`: The VPC configuration of the host to be updated. A VPC must be
configured and the infrastructure to be represented by the host must already be connected
to the VPC.
"""
function update_host(HostArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeconnections(
"UpdateHost",
Dict{String,Any}("HostArn" => HostArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_host(
HostArn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"UpdateHost",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("HostArn" => HostArn), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_repository_link(repository_link_id)
update_repository_link(repository_link_id, params::Dict{String,<:Any})
Updates the association between your connection and a specified external Git repository. A
repository link allows Git sync to monitor and sync changes to files in a specified Git
repository.
# Arguments
- `repository_link_id`: The ID of the repository link to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConnectionArn"`: The Amazon Resource Name (ARN) of the connection for the repository
link to be updated. The updated connection ARN must have the same providerType (such as
GitHub) as the original connection ARN for the repo link.
- `"EncryptionKeyArn"`: The Amazon Resource Name (ARN) of the encryption key for the
repository link to be updated.
"""
function update_repository_link(
RepositoryLinkId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"UpdateRepositoryLink",
Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_repository_link(
RepositoryLinkId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"UpdateRepositoryLink",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RepositoryLinkId" => RepositoryLinkId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sync_blocker(id, resolved_reason, resource_name, sync_type)
update_sync_blocker(id, resolved_reason, resource_name, sync_type, params::Dict{String,<:Any})
Allows you to update the status of a sync blocker, resolving the blocker and allowing
syncing to continue.
# Arguments
- `id`: The ID of the sync blocker to be updated.
- `resolved_reason`: The reason for resolving the sync blocker.
- `resource_name`: The name of the resource for the sync blocker to be updated.
- `sync_type`: The sync type of the sync blocker to be updated.
"""
function update_sync_blocker(
Id,
ResolvedReason,
ResourceName,
SyncType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"UpdateSyncBlocker",
Dict{String,Any}(
"Id" => Id,
"ResolvedReason" => ResolvedReason,
"ResourceName" => ResourceName,
"SyncType" => SyncType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sync_blocker(
Id,
ResolvedReason,
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"UpdateSyncBlocker",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Id" => Id,
"ResolvedReason" => ResolvedReason,
"ResourceName" => ResourceName,
"SyncType" => SyncType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_sync_configuration(resource_name, sync_type)
update_sync_configuration(resource_name, sync_type, params::Dict{String,<:Any})
Updates the sync configuration for your connection and a specified external Git repository.
# Arguments
- `resource_name`: The name of the Amazon Web Services resource for the sync configuration
to be updated.
- `sync_type`: The sync type for the sync configuration to be updated.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Branch"`: The branch for the sync configuration to be updated.
- `"ConfigFile"`: The configuration file for the sync configuration to be updated.
- `"PublishDeploymentStatus"`: Whether to enable or disable publishing of deployment status
to source providers.
- `"RepositoryLinkId"`: The ID of the repository link for the sync configuration to be
updated.
- `"RoleArn"`: The ARN of the IAM role for the sync configuration to be updated.
- `"TriggerResourceUpdateOn"`: When to trigger Git sync to begin the stack update.
"""
function update_sync_configuration(
ResourceName, SyncType; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeconnections(
"UpdateSyncConfiguration",
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_sync_configuration(
ResourceName,
SyncType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeconnections(
"UpdateSyncConfiguration",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceName" => ResourceName, "SyncType" => SyncType),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 78169 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codedeploy
using AWS.Compat
using AWS.UUIDs
"""
add_tags_to_on_premises_instances(instance_names, tags)
add_tags_to_on_premises_instances(instance_names, tags, params::Dict{String,<:Any})
Adds tags to on-premises instances.
# Arguments
- `instance_names`: The names of the on-premises instances to which to add tags.
- `tags`: The tag key-value pairs to add to the on-premises instances. Keys and values are
both required. Keys cannot be null or empty strings. Value-only tags are not allowed.
"""
function add_tags_to_on_premises_instances(
instanceNames, tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"AddTagsToOnPremisesInstances",
Dict{String,Any}("instanceNames" => instanceNames, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_tags_to_on_premises_instances(
instanceNames,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"AddTagsToOnPremisesInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("instanceNames" => instanceNames, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_application_revisions(application_name, revisions)
batch_get_application_revisions(application_name, revisions, params::Dict{String,<:Any})
Gets information about one or more application revisions. The maximum number of application
revisions that can be returned is 25.
# Arguments
- `application_name`: The name of an CodeDeploy application about which to get revision
information.
- `revisions`: An array of RevisionLocation objects that specify information to get about
the application revisions, including type and location. The maximum number of
RevisionLocation objects you can specify is 25.
"""
function batch_get_application_revisions(
applicationName, revisions; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetApplicationRevisions",
Dict{String,Any}("applicationName" => applicationName, "revisions" => revisions);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_application_revisions(
applicationName,
revisions,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetApplicationRevisions",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName, "revisions" => revisions
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_applications(application_names)
batch_get_applications(application_names, params::Dict{String,<:Any})
Gets information about one or more applications. The maximum number of applications that
can be returned is 100.
# Arguments
- `application_names`: A list of application names separated by spaces. The maximum number
of application names you can specify is 100.
"""
function batch_get_applications(
applicationNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetApplications",
Dict{String,Any}("applicationNames" => applicationNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_applications(
applicationNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetApplications",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationNames" => applicationNames), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_deployment_groups(application_name, deployment_group_names)
batch_get_deployment_groups(application_name, deployment_group_names, params::Dict{String,<:Any})
Gets information about one or more deployment groups.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the applicable
user or Amazon Web Services account.
- `deployment_group_names`: The names of the deployment groups.
"""
function batch_get_deployment_groups(
applicationName, deploymentGroupNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetDeploymentGroups",
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupNames" => deploymentGroupNames,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_deployment_groups(
applicationName,
deploymentGroupNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetDeploymentGroups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupNames" => deploymentGroupNames,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_deployment_instances(deployment_id, instance_ids)
batch_get_deployment_instances(deployment_id, instance_ids, params::Dict{String,<:Any})
This method works, but is deprecated. Use BatchGetDeploymentTargets instead. Returns
an array of one or more instances associated with a deployment. This method works with
EC2/On-premises and Lambda compute platforms. The newer BatchGetDeploymentTargets works
with all compute platforms. The maximum number of instances that can be returned is 25.
# Arguments
- `deployment_id`: The unique ID of a deployment.
- `instance_ids`: The unique IDs of instances used in the deployment. The maximum number of
instance IDs you can specify is 25.
"""
function batch_get_deployment_instances(
deploymentId, instanceIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetDeploymentInstances",
Dict{String,Any}("deploymentId" => deploymentId, "instanceIds" => instanceIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_deployment_instances(
deploymentId,
instanceIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetDeploymentInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"deploymentId" => deploymentId, "instanceIds" => instanceIds
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_deployment_targets(deployment_id, target_ids)
batch_get_deployment_targets(deployment_id, target_ids, params::Dict{String,<:Any})
Returns an array of one or more targets associated with a deployment. This method works
with all compute types and should be used instead of the deprecated
BatchGetDeploymentInstances. The maximum number of targets that can be returned is 25. The
type of targets returned depends on the deployment's compute platform or deployment method:
EC2/On-premises: Information about Amazon EC2 instance targets. Lambda: Information
about Lambda functions targets. Amazon ECS: Information about Amazon ECS service
targets. CloudFormation: Information about targets of blue/green deployments initiated
by a CloudFormation stack update.
# Arguments
- `deployment_id`: The unique ID of a deployment.
- `target_ids`: The unique IDs of the deployment targets. The compute platform of the
deployment determines the type of the targets and their formats. The maximum number of
deployment target IDs you can specify is 25. For deployments that use the
EC2/On-premises compute platform, the target IDs are Amazon EC2 or on-premises instances
IDs, and their target type is instanceTarget. For deployments that use the Lambda
compute platform, the target IDs are the names of Lambda functions, and their target type
is instanceTarget. For deployments that use the Amazon ECS compute platform, the target
IDs are pairs of Amazon ECS clusters and services specified using the format
<clustername>:<servicename>. Their target type is ecsTarget. For
deployments that are deployed with CloudFormation, the target IDs are CloudFormation stack
IDs. Their target type is cloudFormationTarget.
"""
function batch_get_deployment_targets(
deploymentId, targetIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetDeploymentTargets",
Dict{String,Any}("deploymentId" => deploymentId, "targetIds" => targetIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_deployment_targets(
deploymentId,
targetIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetDeploymentTargets",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentId" => deploymentId, "targetIds" => targetIds),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_deployments(deployment_ids)
batch_get_deployments(deployment_ids, params::Dict{String,<:Any})
Gets information about one or more deployments. The maximum number of deployments that can
be returned is 25.
# Arguments
- `deployment_ids`: A list of deployment IDs, separated by spaces. The maximum number of
deployment IDs you can specify is 25.
"""
function batch_get_deployments(
deploymentIds; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetDeployments",
Dict{String,Any}("deploymentIds" => deploymentIds);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_deployments(
deploymentIds,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetDeployments",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deploymentIds" => deploymentIds), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_on_premises_instances(instance_names)
batch_get_on_premises_instances(instance_names, params::Dict{String,<:Any})
Gets information about one or more on-premises instances. The maximum number of on-premises
instances that can be returned is 25.
# Arguments
- `instance_names`: The names of the on-premises instances about which to get information.
The maximum number of instance names you can specify is 25.
"""
function batch_get_on_premises_instances(
instanceNames; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"BatchGetOnPremisesInstances",
Dict{String,Any}("instanceNames" => instanceNames);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_on_premises_instances(
instanceNames,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"BatchGetOnPremisesInstances",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("instanceNames" => instanceNames), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
continue_deployment()
continue_deployment(params::Dict{String,<:Any})
For a blue/green deployment, starts the process of rerouting traffic from instances in the
original environment to instances in the replacement environment without waiting for a
specified wait time to elapse. (Traffic rerouting, which is achieved by registering
instances in the replacement environment with the load balancer, can start as soon as all
instances have a status of Ready.)
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deploymentId"`: The unique ID of a blue/green deployment for which you want to start
rerouting traffic to the replacement environment.
- `"deploymentWaitType"`: The status of the deployment's waiting period. READY_WAIT
indicates that the deployment is ready to start shifting traffic. TERMINATION_WAIT
indicates that the traffic is shifted, but the original target is not terminated.
"""
function continue_deployment(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"ContinueDeployment"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function continue_deployment(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ContinueDeployment", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
create_application(application_name)
create_application(application_name, params::Dict{String,<:Any})
Creates an application.
# Arguments
- `application_name`: The name of the application. This name must be unique with the
applicable user or Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computePlatform"`: The destination platform type for the deployment (Lambda, Server,
or ECS).
- `"tags"`: The metadata that you apply to CodeDeploy applications to help you organize
and categorize them. Each tag consists of a key and an optional value, both of which you
define.
"""
function create_application(
applicationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"CreateApplication",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_application(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"CreateApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment(application_name)
create_deployment(application_name, params::Dict{String,<:Any})
Deploys an application revision through the specified deployment group.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"autoRollbackConfiguration"`: Configuration information for an automatic rollback that
is added when a deployment is created.
- `"deploymentConfigName"`: The name of a deployment configuration associated with the user
or Amazon Web Services account. If not specified, the value configured in the deployment
group is used as the default. If the deployment group does not have a deployment
configuration associated with it, CodeDeployDefault.OneAtATime is used by default.
- `"deploymentGroupName"`: The name of the deployment group.
- `"description"`: A comment about the deployment.
- `"fileExistsBehavior"`: Information about how CodeDeploy handles files that already exist
in a deployment target location but weren't part of the previous successful deployment. The
fileExistsBehavior parameter takes any of the following values: DISALLOW: The deployment
fails. This is also the default behavior if no option is specified. OVERWRITE: The
version of the file from the application revision currently being deployed replaces the
version already on the instance. RETAIN: The version of the file already on the instance
is kept and used as part of the new deployment.
- `"ignoreApplicationStopFailures"`: If true, then if an ApplicationStop,
BeforeBlockTraffic, or AfterBlockTraffic deployment lifecycle event to an instance fails,
then the deployment continues to the next deployment lifecycle event. For example, if
ApplicationStop fails, the deployment continues with DownloadBundle. If BeforeBlockTraffic
fails, the deployment continues with BlockTraffic. If AfterBlockTraffic fails, the
deployment continues with ApplicationStop. If false or not specified, then if a lifecycle
event fails during a deployment to an instance, that deployment fails. If deployment to
that instance is part of an overall deployment and the number of healthy hosts is not less
than the minimum number of healthy hosts, then a deployment to the next instance is
attempted. During a deployment, the CodeDeploy agent runs the scripts specified for
ApplicationStop, BeforeBlockTraffic, and AfterBlockTraffic in the AppSpec file from the
previous successful deployment. (All other scripts are run from the AppSpec file in the
current deployment.) If one of these scripts contains an error and does not run
successfully, the deployment can fail. If the cause of the failure is a script from the
last successful deployment that will never run successfully, create a new deployment and
use ignoreApplicationStopFailures to specify that the ApplicationStop, BeforeBlockTraffic,
and AfterBlockTraffic failures should be ignored.
- `"overrideAlarmConfiguration"`: Allows you to specify information about alarms associated
with a deployment. The alarm configuration that you specify here will override the alarm
configuration at the deployment group level. Consider overriding the alarm configuration if
you have set up alarms at the deployment group level that are causing deployment failures.
In this case, you would call CreateDeployment to create a new deployment that uses a
previous application revision that is known to work, and set its alarm configuration to
turn off alarm polling. Turning off alarm polling ensures that the new deployment proceeds
without being blocked by the alarm that was generated by the previous, failed, deployment.
If you specify an overrideAlarmConfiguration, you need the UpdateDeploymentGroup IAM
permission when calling CreateDeployment.
- `"revision"`: The type and location of the revision to deploy.
- `"targetInstances"`: Information about the instances that belong to the replacement
environment in a blue/green deployment.
- `"updateOutdatedInstancesOnly"`: Indicates whether to deploy to all instances or only to
instances that are not running the latest application revision.
"""
function create_deployment(
applicationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"CreateDeployment",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"CreateDeployment",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment_config(deployment_config_name)
create_deployment_config(deployment_config_name, params::Dict{String,<:Any})
Creates a deployment configuration.
# Arguments
- `deployment_config_name`: The name of the deployment configuration to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"computePlatform"`: The destination platform type for the deployment (Lambda, Server, or
ECS).
- `"minimumHealthyHosts"`: The minimum number of healthy instances that should be available
at any time during the deployment. There are two parameters expected in the input: type and
value. The type parameter takes either of the following values: HOST_COUNT: The value
parameter represents the minimum number of healthy instances as an absolute value.
FLEET_PERCENT: The value parameter represents the minimum number of healthy instances as a
percentage of the total number of instances in the deployment. If you specify
FLEET_PERCENT, at the start of the deployment, CodeDeploy converts the percentage to the
equivalent number of instances and rounds up fractional instances. The value parameter
takes an integer. For example, to set a minimum of 95% healthy instance, specify a type of
FLEET_PERCENT and a value of 95.
- `"trafficRoutingConfig"`: The configuration that specifies how the deployment traffic is
routed.
- `"zonalConfig"`: Configure the ZonalConfig object if you want CodeDeploy to deploy your
application to one Availability Zone at a time, within an Amazon Web Services Region. For
more information about the zonal configuration feature, see zonal configuration in the
CodeDeploy User Guide.
"""
function create_deployment_config(
deploymentConfigName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"CreateDeploymentConfig",
Dict{String,Any}("deploymentConfigName" => deploymentConfigName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment_config(
deploymentConfigName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"CreateDeploymentConfig",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentConfigName" => deploymentConfigName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_deployment_group(application_name, deployment_group_name, service_role_arn)
create_deployment_group(application_name, deployment_group_name, service_role_arn, params::Dict{String,<:Any})
Creates a deployment group to which application revisions are deployed.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
- `deployment_group_name`: The name of a new deployment group for the specified application.
- `service_role_arn`: A service role Amazon Resource Name (ARN) that allows CodeDeploy to
act on the user's behalf when interacting with Amazon Web Services services.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alarmConfiguration"`: Information to add about Amazon CloudWatch alarms when the
deployment group is created.
- `"autoRollbackConfiguration"`: Configuration information for an automatic rollback that
is added when a deployment group is created.
- `"autoScalingGroups"`: A list of associated Amazon EC2 Auto Scaling groups.
- `"blueGreenDeploymentConfiguration"`: Information about blue/green deployment options for
a deployment group.
- `"deploymentConfigName"`: If specified, the deployment configuration name can be either
one of the predefined configurations provided with CodeDeploy or a custom deployment
configuration that you create by calling the create deployment configuration operation.
CodeDeployDefault.OneAtATime is the default deployment configuration. It is used if a
configuration isn't specified for the deployment or deployment group. For more information
about the predefined deployment configurations in CodeDeploy, see Working with Deployment
Configurations in CodeDeploy in the CodeDeploy User Guide.
- `"deploymentStyle"`: Information about the type of deployment, in-place or blue/green,
that you want to run and whether to route deployment traffic behind a load balancer.
- `"ec2TagFilters"`: The Amazon EC2 tags on which to filter. The deployment group includes
Amazon EC2 instances with any of the specified tags. Cannot be used in the same call as
ec2TagSet.
- `"ec2TagSet"`: Information about groups of tags applied to Amazon EC2 instances. The
deployment group includes only Amazon EC2 instances identified by all the tag groups.
Cannot be used in the same call as ec2TagFilters.
- `"ecsServices"`: The target Amazon ECS services in the deployment group. This applies
only to deployment groups that use the Amazon ECS compute platform. A target Amazon ECS
service is specified as an Amazon ECS cluster and service name pair using the format
<clustername>:<servicename>.
- `"loadBalancerInfo"`: Information about the load balancer used in a deployment.
- `"onPremisesInstanceTagFilters"`: The on-premises instance tags on which to filter. The
deployment group includes on-premises instances with any of the specified tags. Cannot be
used in the same call as OnPremisesTagSet.
- `"onPremisesTagSet"`: Information about groups of tags applied to on-premises instances.
The deployment group includes only on-premises instances identified by all of the tag
groups. Cannot be used in the same call as onPremisesInstanceTagFilters.
- `"outdatedInstancesStrategy"`: Indicates what happens when new Amazon EC2 instances are
launched mid-deployment and do not receive the deployed application revision. If this
option is set to UPDATE or is unspecified, CodeDeploy initiates one or more 'auto-update
outdated instances' deployments to apply the deployed application revision to the new
Amazon EC2 instances. If this option is set to IGNORE, CodeDeploy does not initiate a
deployment to update the new Amazon EC2 instances. This may result in instances having
different revisions.
- `"tags"`: The metadata that you apply to CodeDeploy deployment groups to help you
organize and categorize them. Each tag consists of a key and an optional value, both of
which you define.
- `"terminationHookEnabled"`: This parameter only applies if you are using CodeDeploy with
Amazon EC2 Auto Scaling. For more information, see Integrating CodeDeploy with Amazon EC2
Auto Scaling in the CodeDeploy User Guide. Set terminationHookEnabled to true to have
CodeDeploy install a termination hook into your Auto Scaling group when you create a
deployment group. When this hook is installed, CodeDeploy will perform termination
deployments. For information about termination deployments, see Enabling termination
deployments during Auto Scaling scale-in events in the CodeDeploy User Guide. For more
information about Auto Scaling scale-in events, see the Scale in topic in the Amazon EC2
Auto Scaling User Guide.
- `"triggerConfigurations"`: Information about triggers to create when the deployment group
is created. For examples, see Create a Trigger for an CodeDeploy Event in the CodeDeploy
User Guide.
"""
function create_deployment_group(
applicationName,
deploymentGroupName,
serviceRoleArn;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"CreateDeploymentGroup",
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
"serviceRoleArn" => serviceRoleArn,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_deployment_group(
applicationName,
deploymentGroupName,
serviceRoleArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"CreateDeploymentGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
"serviceRoleArn" => serviceRoleArn,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_application(application_name)
delete_application(application_name, params::Dict{String,<:Any})
Deletes an application.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
"""
function delete_application(
applicationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteApplication",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_application(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"DeleteApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_deployment_config(deployment_config_name)
delete_deployment_config(deployment_config_name, params::Dict{String,<:Any})
Deletes a deployment configuration. A deployment configuration cannot be deleted if it is
currently in use. Predefined configurations cannot be deleted.
# Arguments
- `deployment_config_name`: The name of a deployment configuration associated with the user
or Amazon Web Services account.
"""
function delete_deployment_config(
deploymentConfigName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteDeploymentConfig",
Dict{String,Any}("deploymentConfigName" => deploymentConfigName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_deployment_config(
deploymentConfigName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"DeleteDeploymentConfig",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentConfigName" => deploymentConfigName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_deployment_group(application_name, deployment_group_name)
delete_deployment_group(application_name, deployment_group_name, params::Dict{String,<:Any})
Deletes a deployment group.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
- `deployment_group_name`: The name of a deployment group for the specified application.
"""
function delete_deployment_group(
applicationName, deploymentGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteDeploymentGroup",
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_deployment_group(
applicationName,
deploymentGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"DeleteDeploymentGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_git_hub_account_token()
delete_git_hub_account_token(params::Dict{String,<:Any})
Deletes a GitHub account connection.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tokenName"`: The name of the GitHub account connection to delete.
"""
function delete_git_hub_account_token(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"DeleteGitHubAccountToken"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function delete_git_hub_account_token(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteGitHubAccountToken",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_resources_by_external_id()
delete_resources_by_external_id(params::Dict{String,<:Any})
Deletes resources linked to an external ID. This action only applies if you have configured
blue/green deployments through CloudFormation. It is not necessary to call this action
directly. CloudFormation calls it on your behalf when it needs to delete stack resources.
This action is offered publicly in case you need to delete resources to comply with General
Data Protection Regulation (GDPR) requirements.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"externalId"`: The unique ID of an external resource (for example, a CloudFormation
stack ID) that is linked to one or more CodeDeploy resources.
"""
function delete_resources_by_external_id(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteResourcesByExternalId";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_resources_by_external_id(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeleteResourcesByExternalId",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_on_premises_instance(instance_name)
deregister_on_premises_instance(instance_name, params::Dict{String,<:Any})
Deregisters an on-premises instance.
# Arguments
- `instance_name`: The name of the on-premises instance to deregister.
"""
function deregister_on_premises_instance(
instanceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"DeregisterOnPremisesInstance",
Dict{String,Any}("instanceName" => instanceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_on_premises_instance(
instanceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"DeregisterOnPremisesInstance",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("instanceName" => instanceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_application(application_name)
get_application(application_name, params::Dict{String,<:Any})
Gets information about an application.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
"""
function get_application(applicationName; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"GetApplication",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_application(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetApplication",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_application_revision(application_name, revision)
get_application_revision(application_name, revision, params::Dict{String,<:Any})
Gets information about an application revision.
# Arguments
- `application_name`: The name of the application that corresponds to the revision.
- `revision`: Information about the application revision to get, including type and
location.
"""
function get_application_revision(
applicationName, revision; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetApplicationRevision",
Dict{String,Any}("applicationName" => applicationName, "revision" => revision);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_application_revision(
applicationName,
revision,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetApplicationRevision",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName, "revision" => revision
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment(deployment_id)
get_deployment(deployment_id, params::Dict{String,<:Any})
Gets information about a deployment. The content property of the appSpecContent object in
the returned revision is always null. Use GetApplicationRevision and the sha256 property of
the returned appSpecContent object to get the content of the deployment’s AppSpec file.
# Arguments
- `deployment_id`: The unique ID of a deployment associated with the user or Amazon Web
Services account.
"""
function get_deployment(deploymentId; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"GetDeployment",
Dict{String,Any}("deploymentId" => deploymentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment(
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetDeployment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deploymentId" => deploymentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment_config(deployment_config_name)
get_deployment_config(deployment_config_name, params::Dict{String,<:Any})
Gets information about a deployment configuration.
# Arguments
- `deployment_config_name`: The name of a deployment configuration associated with the user
or Amazon Web Services account.
"""
function get_deployment_config(
deploymentConfigName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetDeploymentConfig",
Dict{String,Any}("deploymentConfigName" => deploymentConfigName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment_config(
deploymentConfigName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetDeploymentConfig",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentConfigName" => deploymentConfigName),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment_group(application_name, deployment_group_name)
get_deployment_group(application_name, deployment_group_name, params::Dict{String,<:Any})
Gets information about a deployment group.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
- `deployment_group_name`: The name of a deployment group for the specified application.
"""
function get_deployment_group(
applicationName, deploymentGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetDeploymentGroup",
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment_group(
applicationName,
deploymentGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetDeploymentGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName,
"deploymentGroupName" => deploymentGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment_instance(deployment_id, instance_id)
get_deployment_instance(deployment_id, instance_id, params::Dict{String,<:Any})
Gets information about an instance as part of a deployment.
# Arguments
- `deployment_id`: The unique ID of a deployment.
- `instance_id`: The unique ID of an instance in the deployment group.
"""
function get_deployment_instance(
deploymentId, instanceId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetDeploymentInstance",
Dict{String,Any}("deploymentId" => deploymentId, "instanceId" => instanceId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment_instance(
deploymentId,
instanceId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetDeploymentInstance",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"deploymentId" => deploymentId, "instanceId" => instanceId
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_deployment_target(deployment_id, target_id)
get_deployment_target(deployment_id, target_id, params::Dict{String,<:Any})
Returns information about a deployment target.
# Arguments
- `deployment_id`: The unique ID of a deployment.
- `target_id`: The unique ID of a deployment target.
"""
function get_deployment_target(
deploymentId, targetId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetDeploymentTarget",
Dict{String,Any}("deploymentId" => deploymentId, "targetId" => targetId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_deployment_target(
deploymentId,
targetId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetDeploymentTarget",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("deploymentId" => deploymentId, "targetId" => targetId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_on_premises_instance(instance_name)
get_on_premises_instance(instance_name, params::Dict{String,<:Any})
Gets information about an on-premises instance.
# Arguments
- `instance_name`: The name of the on-premises instance about which to get information.
"""
function get_on_premises_instance(
instanceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"GetOnPremisesInstance",
Dict{String,Any}("instanceName" => instanceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_on_premises_instance(
instanceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"GetOnPremisesInstance",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("instanceName" => instanceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_application_revisions(application_name)
list_application_revisions(application_name, params::Dict{String,<:Any})
Lists information about revisions for an application.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deployed"`: Whether to list revisions based on whether the revision is the target
revision of a deployment group: include: List revisions that are target revisions of a
deployment group. exclude: Do not list revisions that are target revisions of a
deployment group. ignore: List all revisions.
- `"nextToken"`: An identifier returned from the previous ListApplicationRevisions call. It
can be used to return the next set of applications in the list.
- `"s3Bucket"`: An Amazon S3 bucket name to limit the search for revisions. If set to
null, all of the user's buckets are searched.
- `"s3KeyPrefix"`: A key prefix for the set of Amazon S3 objects to limit the search for
revisions.
- `"sortBy"`: The column name to use to sort the list results: registerTime: Sort by the
time the revisions were registered with CodeDeploy. firstUsedTime: Sort by the time the
revisions were first used in a deployment. lastUsedTime: Sort by the time the revisions
were last used in a deployment. If not specified or set to null, the results are
returned in an arbitrary order.
- `"sortOrder"`: The order in which to sort the list results: ascending: ascending
order. descending: descending order. If not specified, the results are sorted in
ascending order. If set to null, the results are sorted in an arbitrary order.
"""
function list_application_revisions(
applicationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListApplicationRevisions",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_application_revisions(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"ListApplicationRevisions",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_applications()
list_applications(params::Dict{String,<:Any})
Lists the applications registered with the user or Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An identifier returned from the previous list applications call. It can be
used to return the next set of applications in the list.
"""
function list_applications(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"ListApplications"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_applications(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListApplications", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_deployment_configs()
list_deployment_configs(params::Dict{String,<:Any})
Lists the deployment configurations with the user or Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An identifier returned from the previous ListDeploymentConfigs call. It
can be used to return the next set of deployment configurations in the list.
"""
function list_deployment_configs(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"ListDeploymentConfigs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_deployment_configs(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListDeploymentConfigs",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployment_groups(application_name)
list_deployment_groups(application_name, params::Dict{String,<:Any})
Lists the deployment groups for an application registered with the Amazon Web Services user
or Amazon Web Services account.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An identifier returned from the previous list deployment groups call. It
can be used to return the next set of deployment groups in the list.
"""
function list_deployment_groups(
applicationName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListDeploymentGroups",
Dict{String,Any}("applicationName" => applicationName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_deployment_groups(
applicationName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"ListDeploymentGroups",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("applicationName" => applicationName), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployment_instances(deployment_id)
list_deployment_instances(deployment_id, params::Dict{String,<:Any})
The newer BatchGetDeploymentTargets should be used instead because it works with all
compute types. ListDeploymentInstances throws an exception if it is used with a compute
platform other than EC2/On-premises or Lambda. Lists the instance for a deployment
associated with the user or Amazon Web Services account.
# Arguments
- `deployment_id`: The unique ID of a deployment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"instanceStatusFilter"`: A subset of instances to list by status: Pending: Include
those instances with pending deployments. InProgress: Include those instances where
deployments are still in progress. Succeeded: Include those instances with successful
deployments. Failed: Include those instances with failed deployments. Skipped:
Include those instances with skipped deployments. Unknown: Include those instances with
deployments in an unknown state.
- `"instanceTypeFilter"`: The set of instances in a blue/green deployment, either those in
the original environment (\"BLUE\") or those in the replacement environment (\"GREEN\"),
for which you want to view instance information.
- `"nextToken"`: An identifier returned from the previous list deployment instances call.
It can be used to return the next set of deployment instances in the list.
"""
function list_deployment_instances(
deploymentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListDeploymentInstances",
Dict{String,Any}("deploymentId" => deploymentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_deployment_instances(
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"ListDeploymentInstances",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deploymentId" => deploymentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployment_targets(deployment_id)
list_deployment_targets(deployment_id, params::Dict{String,<:Any})
Returns an array of target IDs that are associated a deployment.
# Arguments
- `deployment_id`: The unique ID of a deployment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: A token identifier returned from the previous ListDeploymentTargets call.
It can be used to return the next set of deployment targets in the list.
- `"targetFilters"`: A key used to filter the returned targets. The two valid values are:
TargetStatus - A TargetStatus filter string can be Failed, InProgress, Pending, Ready,
Skipped, Succeeded, or Unknown. ServerInstanceLabel - A ServerInstanceLabel filter
string can be Blue or Green.
"""
function list_deployment_targets(
deploymentId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListDeploymentTargets",
Dict{String,Any}("deploymentId" => deploymentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_deployment_targets(
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"ListDeploymentTargets",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deploymentId" => deploymentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_deployments()
list_deployments(params::Dict{String,<:Any})
Lists the deployments in a deployment group for an application registered with the user or
Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"applicationName"`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account. If applicationName is specified, then deploymentGroupName
must be specified. If it is not specified, then deploymentGroupName must not be specified.
- `"createTimeRange"`: A time range (start and end) for returning a subset of the list of
deployments.
- `"deploymentGroupName"`: The name of a deployment group for the specified application.
If deploymentGroupName is specified, then applicationName must be specified. If it is not
specified, then applicationName must not be specified.
- `"externalId"`: The unique ID of an external resource for returning deployments linked to
the external resource.
- `"includeOnlyStatuses"`: A subset of deployments to list by status: Created: Include
created deployments in the resulting list. Queued: Include queued deployments in the
resulting list. In Progress: Include in-progress deployments in the resulting list.
Succeeded: Include successful deployments in the resulting list. Failed: Include failed
deployments in the resulting list. Stopped: Include stopped deployments in the resulting
list.
- `"nextToken"`: An identifier returned from the previous list deployments call. It can be
used to return the next set of deployments in the list.
"""
function list_deployments(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"ListDeployments"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_deployments(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListDeployments", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_git_hub_account_token_names()
list_git_hub_account_token_names(params::Dict{String,<:Any})
Lists the names of stored connections to GitHub accounts.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An identifier returned from the previous ListGitHubAccountTokenNames call.
It can be used to return the next set of names in the list.
"""
function list_git_hub_account_token_names(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListGitHubAccountTokenNames";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_git_hub_account_token_names(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListGitHubAccountTokenNames",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_on_premises_instances()
list_on_premises_instances(params::Dict{String,<:Any})
Gets a list of names for one or more on-premises instances. Unless otherwise specified,
both registered and deregistered on-premises instance names are listed. To list only
registered or deregistered on-premises instance names, use the registration status
parameter.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: An identifier returned from the previous list on-premises instances call.
It can be used to return the next set of on-premises instances in the list.
- `"registrationStatus"`: The registration status of the on-premises instances:
Deregistered: Include deregistered on-premises instances in the resulting list.
Registered: Include registered on-premises instances in the resulting list.
- `"tagFilters"`: The on-premises instance tags that are used to restrict the on-premises
instance names returned.
"""
function list_on_premises_instances(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"ListOnPremisesInstances"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_on_premises_instances(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListOnPremisesInstances",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of tags for the resource identified by a specified Amazon Resource Name
(ARN). Tags are used to organize and categorize your CodeDeploy resources.
# Arguments
- `resource_arn`: The ARN of a CodeDeploy resource. ListTagsForResource returns all the
tags associated with the resource that is identified by the ResourceArn.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"NextToken"`: An identifier returned from the previous ListTagsForResource call. It can
be used to return the next set of applications in the list.
"""
function list_tags_for_resource(
ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"ListTagsForResource",
Dict{String,Any}("ResourceArn" => ResourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
ResourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_lifecycle_event_hook_execution_status()
put_lifecycle_event_hook_execution_status(params::Dict{String,<:Any})
Sets the result of a Lambda validation function. The function validates lifecycle hooks
during a deployment that uses the Lambda or Amazon ECS compute platform. For Lambda
deployments, the available lifecycle hooks are BeforeAllowTraffic and AfterAllowTraffic.
For Amazon ECS deployments, the available lifecycle hooks are BeforeInstall, AfterInstall,
AfterAllowTestTraffic, BeforeAllowTraffic, and AfterAllowTraffic. Lambda validation
functions return Succeeded or Failed. For more information, see AppSpec 'hooks' Section for
an Lambda Deployment and AppSpec 'hooks' Section for an Amazon ECS Deployment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deploymentId"`: The unique ID of a deployment. Pass this ID to a Lambda function that
validates a deployment lifecycle event.
- `"lifecycleEventHookExecutionId"`: The execution ID of a deployment's lifecycle hook. A
deployment lifecycle hook is specified in the hooks section of the AppSpec file.
- `"status"`: The result of a Lambda function that validates a deployment lifecycle event.
The values listed in Valid Values are valid for lifecycle statuses in general; however,
only Succeeded and Failed can be passed successfully in your API call.
"""
function put_lifecycle_event_hook_execution_status(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"PutLifecycleEventHookExecutionStatus";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_lifecycle_event_hook_execution_status(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"PutLifecycleEventHookExecutionStatus",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_application_revision(application_name, revision)
register_application_revision(application_name, revision, params::Dict{String,<:Any})
Registers with CodeDeploy a revision for the specified application.
# Arguments
- `application_name`: The name of an CodeDeploy application associated with the user or
Amazon Web Services account.
- `revision`: Information about the application revision to register, including type and
location.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"description"`: A comment about the revision.
"""
function register_application_revision(
applicationName, revision; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"RegisterApplicationRevision",
Dict{String,Any}("applicationName" => applicationName, "revision" => revision);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_application_revision(
applicationName,
revision,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"RegisterApplicationRevision",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName, "revision" => revision
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_on_premises_instance(instance_name)
register_on_premises_instance(instance_name, params::Dict{String,<:Any})
Registers an on-premises instance. Only one IAM ARN (an IAM session ARN or IAM user ARN)
is supported in the request. You cannot use both.
# Arguments
- `instance_name`: The name of the on-premises instance to register.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"iamSessionArn"`: The ARN of the IAM session to associate with the on-premises instance.
- `"iamUserArn"`: The ARN of the user to associate with the on-premises instance.
"""
function register_on_premises_instance(
instanceName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"RegisterOnPremisesInstance",
Dict{String,Any}("instanceName" => instanceName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_on_premises_instance(
instanceName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"RegisterOnPremisesInstance",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("instanceName" => instanceName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_tags_from_on_premises_instances(instance_names, tags)
remove_tags_from_on_premises_instances(instance_names, tags, params::Dict{String,<:Any})
Removes one or more tags from one or more on-premises instances.
# Arguments
- `instance_names`: The names of the on-premises instances from which to remove tags.
- `tags`: The tag key-value pairs to remove from the on-premises instances.
"""
function remove_tags_from_on_premises_instances(
instanceNames, tags; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"RemoveTagsFromOnPremisesInstances",
Dict{String,Any}("instanceNames" => instanceNames, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_tags_from_on_premises_instances(
instanceNames,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"RemoveTagsFromOnPremisesInstances",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("instanceNames" => instanceNames, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
skip_wait_time_for_instance_termination()
skip_wait_time_for_instance_termination(params::Dict{String,<:Any})
In a blue/green deployment, overrides any specified wait time and starts terminating
instances immediately after the traffic routing is complete.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"deploymentId"`: The unique ID of a blue/green deployment for which you want to skip
the instance termination wait time.
"""
function skip_wait_time_for_instance_termination(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"SkipWaitTimeForInstanceTermination";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function skip_wait_time_for_instance_termination(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"SkipWaitTimeForInstanceTermination",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_deployment(deployment_id)
stop_deployment(deployment_id, params::Dict{String,<:Any})
Attempts to stop an ongoing deployment.
# Arguments
- `deployment_id`: The unique ID of a deployment.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"autoRollbackEnabled"`: Indicates, when a deployment is stopped, whether instances that
have been updated should be rolled back to the previous version of the application
revision.
"""
function stop_deployment(deploymentId; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"StopDeployment",
Dict{String,Any}("deploymentId" => deploymentId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_deployment(
deploymentId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"StopDeployment",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("deploymentId" => deploymentId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Associates the list of tags in the input Tags parameter with the resource identified by
the ResourceArn input parameter.
# Arguments
- `resource_arn`: The ARN of a resource, such as a CodeDeploy application or deployment
group.
- `tags`: A list of tags that TagResource associates with a resource. The resource is
identified by the ResourceArn input parameter.
"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"TagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
ResourceArn,
Tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Disassociates a resource from a list of tags. The resource is identified by the
ResourceArn input parameter. The tags are identified by the list of keys in the TagKeys
input parameter.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) that specifies from which resource to
disassociate the tags with the keys in the TagKeys input parameter.
- `tag_keys`: A list of keys of Tag objects. The Tag objects identified by the keys are
disassociated from the resource specified by the ResourceArn input parameter.
"""
function untag_resource(
ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"UntagResource",
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
ResourceArn,
TagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_application()
update_application(params::Dict{String,<:Any})
Changes the name of an application.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"applicationName"`: The current name of the application you want to change.
- `"newApplicationName"`: The new name to give the application.
"""
function update_application(; aws_config::AbstractAWSConfig=global_aws_config())
return codedeploy(
"UpdateApplication"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function update_application(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codedeploy(
"UpdateApplication", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
update_deployment_group(application_name, current_deployment_group_name)
update_deployment_group(application_name, current_deployment_group_name, params::Dict{String,<:Any})
Changes information about a deployment group.
# Arguments
- `application_name`: The application name that corresponds to the deployment group to
update.
- `current_deployment_group_name`: The current name of the deployment group.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"alarmConfiguration"`: Information to add or change about Amazon CloudWatch alarms when
the deployment group is updated.
- `"autoRollbackConfiguration"`: Information for an automatic rollback configuration that
is added or changed when a deployment group is updated.
- `"autoScalingGroups"`: The replacement list of Auto Scaling groups to be included in the
deployment group, if you want to change them. To keep the Auto Scaling groups, enter
their names or do not specify this parameter. To remove Auto Scaling groups, specify a
non-null empty list of Auto Scaling group names to detach all CodeDeploy-managed Auto
Scaling lifecycle hooks. For examples, see Amazon EC2 instances in an Amazon EC2 Auto
Scaling group fail to launch and receive the error \"Heartbeat Timeout\" in the CodeDeploy
User Guide.
- `"blueGreenDeploymentConfiguration"`: Information about blue/green deployment options for
a deployment group.
- `"deploymentConfigName"`: The replacement deployment configuration name to use, if you
want to change it.
- `"deploymentStyle"`: Information about the type of deployment, either in-place or
blue/green, you want to run and whether to route deployment traffic behind a load balancer.
- `"ec2TagFilters"`: The replacement set of Amazon EC2 tags on which to filter, if you want
to change them. To keep the existing tags, enter their names. To remove tags, do not enter
any tag names.
- `"ec2TagSet"`: Information about groups of tags applied to on-premises instances. The
deployment group includes only Amazon EC2 instances identified by all the tag groups.
- `"ecsServices"`: The target Amazon ECS services in the deployment group. This applies
only to deployment groups that use the Amazon ECS compute platform. A target Amazon ECS
service is specified as an Amazon ECS cluster and service name pair using the format
<clustername>:<servicename>.
- `"loadBalancerInfo"`: Information about the load balancer used in a deployment.
- `"newDeploymentGroupName"`: The new name of the deployment group, if you want to change
it.
- `"onPremisesInstanceTagFilters"`: The replacement set of on-premises instance tags on
which to filter, if you want to change them. To keep the existing tags, enter their names.
To remove tags, do not enter any tag names.
- `"onPremisesTagSet"`: Information about an on-premises instance tag set. The deployment
group includes only on-premises instances identified by all the tag groups.
- `"outdatedInstancesStrategy"`: Indicates what happens when new Amazon EC2 instances are
launched mid-deployment and do not receive the deployed application revision. If this
option is set to UPDATE or is unspecified, CodeDeploy initiates one or more 'auto-update
outdated instances' deployments to apply the deployed application revision to the new
Amazon EC2 instances. If this option is set to IGNORE, CodeDeploy does not initiate a
deployment to update the new Amazon EC2 instances. This may result in instances having
different revisions.
- `"serviceRoleArn"`: A replacement ARN for the service role, if you want to change it.
- `"terminationHookEnabled"`: This parameter only applies if you are using CodeDeploy with
Amazon EC2 Auto Scaling. For more information, see Integrating CodeDeploy with Amazon EC2
Auto Scaling in the CodeDeploy User Guide. Set terminationHookEnabled to true to have
CodeDeploy install a termination hook into your Auto Scaling group when you update a
deployment group. When this hook is installed, CodeDeploy will perform termination
deployments. For information about termination deployments, see Enabling termination
deployments during Auto Scaling scale-in events in the CodeDeploy User Guide. For more
information about Auto Scaling scale-in events, see the Scale in topic in the Amazon EC2
Auto Scaling User Guide.
- `"triggerConfigurations"`: Information about triggers to change when the deployment group
is updated. For examples, see Edit a Trigger in a CodeDeploy Deployment Group in the
CodeDeploy User Guide.
"""
function update_deployment_group(
applicationName,
currentDeploymentGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"UpdateDeploymentGroup",
Dict{String,Any}(
"applicationName" => applicationName,
"currentDeploymentGroupName" => currentDeploymentGroupName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_deployment_group(
applicationName,
currentDeploymentGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codedeploy(
"UpdateDeploymentGroup",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"applicationName" => applicationName,
"currentDeploymentGroupName" => currentDeploymentGroupName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 25032 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codeguru_reviewer
using AWS.Compat
using AWS.UUIDs
"""
associate_repository(repository)
associate_repository(repository, params::Dict{String,<:Any})
Use to associate an Amazon Web Services CodeCommit repository or a repository managed by
Amazon Web Services CodeStar Connections with Amazon CodeGuru Reviewer. When you associate
a repository, CodeGuru Reviewer reviews source code changes in the repository's pull
requests and provides automatic recommendations. You can view recommendations using the
CodeGuru Reviewer console. For more information, see Recommendations in Amazon CodeGuru
Reviewer in the Amazon CodeGuru Reviewer User Guide. If you associate a CodeCommit or S3
repository, it must be in the same Amazon Web Services Region and Amazon Web Services
account where its CodeGuru Reviewer code reviews are configured. Bitbucket and GitHub
Enterprise Server repositories are managed by Amazon Web Services CodeStar Connections to
connect to CodeGuru Reviewer. For more information, see Associate a repository in the
Amazon CodeGuru Reviewer User Guide. You cannot use the CodeGuru Reviewer SDK or the
Amazon Web Services CLI to associate a GitHub repository with Amazon CodeGuru Reviewer. To
associate a GitHub repository, use the console. For more information, see Getting started
with CodeGuru Reviewer in the CodeGuru Reviewer User Guide.
# Arguments
- `repository`: The repository to associate.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: Amazon CodeGuru Reviewer uses this value to prevent the
accidental creation of duplicate repository associations if there are failures and retries.
- `"KMSKeyDetails"`: A KMSKeyDetails object that contains: The encryption option for this
repository association. It is either owned by Amazon Web Services Key Management Service
(KMS) (AWS_OWNED_CMK) or customer managed (CUSTOMER_MANAGED_CMK). The ID of the Amazon
Web Services KMS key that is associated with this repository association.
- `"Tags"`: An array of key-value pairs used to tag an associated repository. A tag is a
custom attribute label with two parts: A tag key (for example, CostCenter, Environment,
Project, or Secret). Tag keys are case sensitive. An optional field known as a tag value
(for example, 111122223333, Production, or a team name). Omitting the tag value is the same
as using an empty string. Like tag keys, tag values are case sensitive.
"""
function associate_repository(Repository; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_reviewer(
"POST",
"/associations",
Dict{String,Any}(
"Repository" => Repository, "ClientRequestToken" => string(uuid4())
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function associate_repository(
Repository,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"POST",
"/associations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Repository" => Repository, "ClientRequestToken" => string(uuid4())
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_code_review(name, repository_association_arn, type)
create_code_review(name, repository_association_arn, type, params::Dict{String,<:Any})
Use to create a code review with a CodeReviewType of RepositoryAnalysis. This type of code
review analyzes all code under a specified branch in an associated repository. PullRequest
code reviews are automatically triggered by a pull request.
# Arguments
- `name`: The name of the code review. The name of each code review in your Amazon Web
Services account must be unique.
- `repository_association_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation
object. You can retrieve this ARN by calling ListRepositoryAssociations. A code review can
only be created on an associated repository. This is the ARN of the associated repository.
- `type`: The type of code review to create. This is specified using a CodeReviewType
object. You can create a code review only of type RepositoryAnalysis.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: Amazon CodeGuru Reviewer uses this value to prevent the
accidental creation of duplicate code reviews if there are failures and retries.
"""
function create_code_review(
Name, RepositoryAssociationArn, Type; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"POST",
"/codereviews",
Dict{String,Any}(
"Name" => Name,
"RepositoryAssociationArn" => RepositoryAssociationArn,
"Type" => Type,
"ClientRequestToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_code_review(
Name,
RepositoryAssociationArn,
Type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"POST",
"/codereviews",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"Name" => Name,
"RepositoryAssociationArn" => RepositoryAssociationArn,
"Type" => Type,
"ClientRequestToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_code_review(code_review_arn)
describe_code_review(code_review_arn, params::Dict{String,<:Any})
Returns the metadata associated with the code review along with its status.
# Arguments
- `code_review_arn`: The Amazon Resource Name (ARN) of the CodeReview object.
"""
function describe_code_review(
CodeReviewArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/codereviews/$(CodeReviewArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_code_review(
CodeReviewArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/codereviews/$(CodeReviewArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_recommendation_feedback(code_review_arn, recommendation_id)
describe_recommendation_feedback(code_review_arn, recommendation_id, params::Dict{String,<:Any})
Describes the customer feedback for a CodeGuru Reviewer recommendation.
# Arguments
- `code_review_arn`: The Amazon Resource Name (ARN) of the CodeReview object.
- `recommendation_id`: The recommendation ID that can be used to track the provided
recommendations and then to collect the feedback.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"UserId"`: Optional parameter to describe the feedback for a given user. If this is not
supplied, it defaults to the user making the request. The UserId is an IAM principal that
can be specified as an Amazon Web Services account ID or an Amazon Resource Name (ARN). For
more information, see Specifying a Principal in the Amazon Web Services Identity and
Access Management User Guide.
"""
function describe_recommendation_feedback(
CodeReviewArn, RecommendationId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/feedback/$(CodeReviewArn)",
Dict{String,Any}("RecommendationId" => RecommendationId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_recommendation_feedback(
CodeReviewArn,
RecommendationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/feedback/$(CodeReviewArn)",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("RecommendationId" => RecommendationId), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_repository_association(association_arn)
describe_repository_association(association_arn, params::Dict{String,<:Any})
Returns a RepositoryAssociation object that contains information about the requested
repository association.
# Arguments
- `association_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation object.
You can retrieve this ARN by calling ListRepositoryAssociations.
"""
function describe_repository_association(
AssociationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/associations/$(AssociationArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_repository_association(
AssociationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/associations/$(AssociationArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disassociate_repository(association_arn)
disassociate_repository(association_arn, params::Dict{String,<:Any})
Removes the association between Amazon CodeGuru Reviewer and a repository.
# Arguments
- `association_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation object.
You can retrieve this ARN by calling ListRepositoryAssociations.
"""
function disassociate_repository(
AssociationArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"DELETE",
"/associations/$(AssociationArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disassociate_repository(
AssociationArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"DELETE",
"/associations/$(AssociationArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_code_reviews(type)
list_code_reviews(type, params::Dict{String,<:Any})
Lists all the code reviews that the customer has created in the past 90 days.
# Arguments
- `type`: The type of code reviews to list in the response.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results that are returned per call. The default is
100.
- `"NextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged.
- `"ProviderTypes"`: List of provider types for filtering that needs to be applied before
displaying the result. For example, providerTypes=[GitHub] lists code reviews from GitHub.
- `"RepositoryNames"`: List of repository names for filtering that needs to be applied
before displaying the result.
- `"States"`: List of states for filtering that needs to be applied before displaying the
result. For example, states=[Pending] lists code reviews in the Pending state. The valid
code review states are: Completed: The code review is complete. Pending: The code
review started and has not completed or failed. Failed: The code review failed.
Deleting: The code review is being deleted.
"""
function list_code_reviews(Type; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_reviewer(
"GET",
"/codereviews",
Dict{String,Any}("Type" => Type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_code_reviews(
Type, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/codereviews",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Type" => Type), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_recommendation_feedback(code_review_arn)
list_recommendation_feedback(code_review_arn, params::Dict{String,<:Any})
Returns a list of RecommendationFeedbackSummary objects that contain customer
recommendation feedback for all CodeGuru Reviewer users.
# Arguments
- `code_review_arn`: The Amazon Resource Name (ARN) of the CodeReview object.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results that are returned per call. The default is
100.
- `"NextToken"`: If nextToken is returned, there are more results available. The value of
nextToken is a unique pagination token for each page. Make the call again using the
returned token to retrieve the next page. Keep all other arguments unchanged.
- `"RecommendationIds"`: Used to query the recommendation feedback for a given
recommendation.
- `"UserIds"`: An Amazon Web Services user's account ID or Amazon Resource Name (ARN). Use
this ID to query the recommendation feedback for a code review from that user. The UserId
is an IAM principal that can be specified as an Amazon Web Services account ID or an Amazon
Resource Name (ARN). For more information, see Specifying a Principal in the Amazon Web
Services Identity and Access Management User Guide.
"""
function list_recommendation_feedback(
CodeReviewArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/feedback/$(CodeReviewArn)/RecommendationFeedback";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_recommendation_feedback(
CodeReviewArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/feedback/$(CodeReviewArn)/RecommendationFeedback",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_recommendations(code_review_arn)
list_recommendations(code_review_arn, params::Dict{String,<:Any})
Returns the list of all recommendations for a completed code review.
# Arguments
- `code_review_arn`: The Amazon Resource Name (ARN) of the CodeReview object.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results that are returned per call. The default is
100.
- `"NextToken"`: Pagination token.
"""
function list_recommendations(
CodeReviewArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/codereviews/$(CodeReviewArn)/Recommendations";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_recommendations(
CodeReviewArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/codereviews/$(CodeReviewArn)/Recommendations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_repository_associations()
list_repository_associations(params::Dict{String,<:Any})
Returns a list of RepositoryAssociationSummary objects that contain summary information
about a repository association. You can filter the returned list by ProviderType, Name,
State, and Owner.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of repository association results returned by
ListRepositoryAssociations in paginated output. When this parameter is used,
ListRepositoryAssociations only returns maxResults results in a single page with a
nextToken response element. The remaining results of the initial request can be seen by
sending another ListRepositoryAssociations request with the returned nextToken value. This
value can be between 1 and 100. If this parameter is not used, ListRepositoryAssociations
returns up to 100 results and a nextToken value if applicable.
- `"Name"`: List of repository names to use as a filter.
- `"NextToken"`: The nextToken value returned from a previous paginated
ListRepositoryAssociations request where maxResults was used and the results exceeded the
value of that parameter. Pagination continues from the end of the previous results that
returned the nextToken value. Treat this token as an opaque identifier that is only used
to retrieve the next items in a list and not for other programmatic purposes.
- `"Owner"`: List of owners to use as a filter. For Amazon Web Services CodeCommit, it is
the name of the CodeCommit account that was used to associate the repository. For other
repository source providers, such as Bitbucket and GitHub Enterprise Server, this is name
of the account that was used to associate the repository.
- `"ProviderType"`: List of provider types to use as a filter.
- `"State"`: List of repository association states to use as a filter. The valid repository
association states are: Associated: The repository association is complete.
Associating: CodeGuru Reviewer is: Setting up pull request notifications. This is
required for pull requests to trigger a CodeGuru Reviewer review. If your repository
ProviderType is GitHub, GitHub Enterprise Server, or Bitbucket, CodeGuru Reviewer creates
webhooks in your repository to trigger CodeGuru Reviewer reviews. If you delete these
webhooks, reviews of code in your repository cannot be triggered. Setting up source code
access. This is required for CodeGuru Reviewer to securely clone code in your repository.
Failed: The repository failed to associate or disassociate. Disassociating: CodeGuru
Reviewer is removing the repository's pull request notifications and source code access.
Disassociated: CodeGuru Reviewer successfully disassociated the repository. You can create
a new association with this repository if you want to review source code in it later. You
can control access to code reviews created in anassociated repository with tags after it
has been disassociated. For more information, see Using tags to control access to
associated repositories in the Amazon CodeGuru Reviewer User Guide.
"""
function list_repository_associations(; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_reviewer(
"GET", "/associations"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_repository_associations(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/associations",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns the list of tags associated with an associated repository resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation object. You
can retrieve this ARN by calling ListRepositoryAssociations.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_recommendation_feedback(code_review_arn, reactions, recommendation_id)
put_recommendation_feedback(code_review_arn, reactions, recommendation_id, params::Dict{String,<:Any})
Stores customer feedback for a CodeGuru Reviewer recommendation. When this API is called
again with different reactions the previous feedback is overwritten.
# Arguments
- `code_review_arn`: The Amazon Resource Name (ARN) of the CodeReview object.
- `reactions`: List for storing reactions. Reactions are utf-8 text code for emojis. If you
send an empty list it clears all your feedback.
- `recommendation_id`: The recommendation ID that can be used to track the provided
recommendations and then to collect the feedback.
"""
function put_recommendation_feedback(
CodeReviewArn,
Reactions,
RecommendationId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"PUT",
"/feedback",
Dict{String,Any}(
"CodeReviewArn" => CodeReviewArn,
"Reactions" => Reactions,
"RecommendationId" => RecommendationId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_recommendation_feedback(
CodeReviewArn,
Reactions,
RecommendationId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"PUT",
"/feedback",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"CodeReviewArn" => CodeReviewArn,
"Reactions" => Reactions,
"RecommendationId" => RecommendationId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(tags, resource_arn)
tag_resource(tags, resource_arn, params::Dict{String,<:Any})
Adds one or more tags to an associated repository.
# Arguments
- `tags`: An array of key-value pairs used to tag an associated repository. A tag is a
custom attribute label with two parts: A tag key (for example, CostCenter, Environment,
Project, or Secret). Tag keys are case sensitive. An optional field known as a tag value
(for example, 111122223333, Production, or a team name). Omitting the tag value is the same
as using an empty string. Like tag keys, tag values are case sensitive.
- `resource_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation object. You
can retrieve this ARN by calling ListRepositoryAssociations.
"""
function tag_resource(Tags, resourceArn; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_reviewer(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("Tags" => Tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
Tags,
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("Tags" => Tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes a tag from an associated repository.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the RepositoryAssociation object. You
can retrieve this ARN by calling ListRepositoryAssociations.
- `tag_keys`: A list of the keys for each tag you want to remove from an associated
repository.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_reviewer(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_reviewer(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 17941 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codeguru_security
using AWS.Compat
using AWS.UUIDs
"""
batch_get_findings(finding_identifiers)
batch_get_findings(finding_identifiers, params::Dict{String,<:Any})
Returns a list of requested findings from standard scans.
# Arguments
- `finding_identifiers`: A list of finding identifiers. Each identifier consists of a
scanName and a findingId. You retrieve the findingId when you call GetFindings.
"""
function batch_get_findings(
findingIdentifiers; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"POST",
"/batchGetFindings",
Dict{String,Any}("findingIdentifiers" => findingIdentifiers);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_findings(
findingIdentifiers,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"POST",
"/batchGetFindings",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("findingIdentifiers" => findingIdentifiers), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_scan(resource_id, scan_name)
create_scan(resource_id, scan_name, params::Dict{String,<:Any})
Use to create a scan using code uploaded to an Amazon S3 bucket.
# Arguments
- `resource_id`: The identifier for the resource object to be scanned.
- `scan_name`: The unique name that CodeGuru Security uses to track revisions across
multiple scans of the same resource. Only allowed for a STANDARD scan type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"analysisType"`: The type of analysis you want CodeGuru Security to perform in the scan,
either Security or All. The Security type only generates findings related to security. The
All type generates both security findings and quality findings. Defaults to Security type
if missing.
- `"clientToken"`: The idempotency token for the request. Amazon CodeGuru Security uses
this value to prevent the accidental creation of duplicate scans if there are failures and
retries.
- `"scanType"`: The type of scan, either Standard or Express. Defaults to Standard type if
missing. Express scans run on limited resources and use a limited set of detectors to
analyze your code in near-real time. Standard scans have standard resource limits and use
the full set of detectors to analyze your code.
- `"tags"`: An array of key-value pairs used to tag a scan. A tag is a custom attribute
label with two parts: A tag key. For example, CostCenter, Environment, or Secret. Tag
keys are case sensitive. An optional tag value field. For example, 111122223333,
Production, or a team name. Omitting the tag value is the same as using an empty string.
Tag values are case sensitive.
"""
function create_scan(
resourceId, scanName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"POST",
"/scans",
Dict{String,Any}(
"resourceId" => resourceId,
"scanName" => scanName,
"clientToken" => string(uuid4()),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_scan(
resourceId,
scanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"POST",
"/scans",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"resourceId" => resourceId,
"scanName" => scanName,
"clientToken" => string(uuid4()),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_upload_url(scan_name)
create_upload_url(scan_name, params::Dict{String,<:Any})
Generates a pre-signed URL, request headers used to upload a code resource, and code
artifact identifier for the uploaded resource. You can upload your code resource to the URL
with the request headers using any HTTP client.
# Arguments
- `scan_name`: The name of the scan that will use the uploaded resource. CodeGuru Security
uses the unique scan name to track revisions across multiple scans of the same resource.
Use this scanName when you call CreateScan on the code resource you upload to this URL.
"""
function create_upload_url(scanName; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"POST",
"/uploadUrl",
Dict{String,Any}("scanName" => scanName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_upload_url(
scanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"POST",
"/uploadUrl",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("scanName" => scanName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_account_configuration()
get_account_configuration(params::Dict{String,<:Any})
Use to get the encryption configuration for an account.
"""
function get_account_configuration(; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"GET",
"/accountConfiguration/get";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_account_configuration(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"GET",
"/accountConfiguration/get",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_findings(scan_name)
get_findings(scan_name, params::Dict{String,<:Any})
Returns a list of all findings generated by a particular scan.
# Arguments
- `scan_name`: The name of the scan you want to retrieve findings from.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. Use this
parameter when paginating results. If additional results exist beyond the number you
specify, the nextToken element is returned in the response. Use nextToken in a subsequent
request to retrieve additional results. If not specified, returns 1000 results.
- `"nextToken"`: A token to use for paginating results that are returned in the response.
Set the value of this parameter to null for the first request. For subsequent calls, use
the nextToken value returned from the previous request to continue listing results after
the first page.
- `"status"`: The status of the findings you want to get. Pass either Open, Closed, or All.
"""
function get_findings(scanName; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"GET",
"/findings/$(scanName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_findings(
scanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"GET",
"/findings/$(scanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_metrics_summary(date)
get_metrics_summary(date, params::Dict{String,<:Any})
Returns a summary of metrics for an account from a specified date, including number of open
findings, the categories with most findings, the scans with most open findings, and scans
with most open critical findings.
# Arguments
- `date`: The date you want to retrieve summary metrics from, rounded to the nearest day.
The date must be within the past two years.
"""
function get_metrics_summary(date; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"GET",
"/metrics/summary",
Dict{String,Any}("date" => date);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_metrics_summary(
date, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"GET",
"/metrics/summary",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("date" => date), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_scan(scan_name)
get_scan(scan_name, params::Dict{String,<:Any})
Returns details about a scan, including whether or not a scan has completed.
# Arguments
- `scan_name`: The name of the scan you want to view details about.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"runId"`: UUID that identifies the individual scan run you want to view details about.
You retrieve this when you call the CreateScan operation. Defaults to the latest scan run
if missing.
"""
function get_scan(scanName; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"GET", "/scans/$(scanName)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function get_scan(
scanName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"GET",
"/scans/$(scanName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_findings_metrics(end_date, start_date)
list_findings_metrics(end_date, start_date, params::Dict{String,<:Any})
Returns metrics about all findings in an account within a specified time range.
# Arguments
- `end_date`: The end date of the interval which you want to retrieve metrics from. Round
to the nearest day.
- `start_date`: The start date of the interval which you want to retrieve metrics from.
Rounds to the nearest day.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. Use this
parameter when paginating results. If additional results exist beyond the number you
specify, the nextToken element is returned in the response. Use nextToken in a subsequent
request to retrieve additional results. If not specified, returns 1000 results.
- `"nextToken"`: A token to use for paginating results that are returned in the response.
Set the value of this parameter to null for the first request. For subsequent calls, use
the nextToken value returned from the previous request to continue listing results after
the first page.
"""
function list_findings_metrics(
endDate, startDate; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"GET",
"/metrics/findings",
Dict{String,Any}("endDate" => endDate, "startDate" => startDate);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_findings_metrics(
endDate,
startDate,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"GET",
"/metrics/findings",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("endDate" => endDate, "startDate" => startDate),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_scans()
list_scans(params::Dict{String,<:Any})
Returns a list of all scans in an account. Does not return EXPRESS scans.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in the response. Use this
parameter when paginating results. If additional results exist beyond the number you
specify, the nextToken element is returned in the response. Use nextToken in a subsequent
request to retrieve additional results. If not specified, returns 100 results.
- `"nextToken"`: A token to use for paginating results that are returned in the response.
Set the value of this parameter to null for the first request. For subsequent calls, use
the nextToken value returned from the previous request to continue listing results after
the first page.
"""
function list_scans(; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"GET", "/scans"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_scans(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"GET", "/scans", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of all tags associated with a scan.
# Arguments
- `resource_arn`: The ARN of the ScanName object. You can retrieve this ARN by calling
CreateScan, ListScans, or GetScan.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Use to add one or more tags to an existing scan.
# Arguments
- `resource_arn`: The ARN of the ScanName object. You can retrieve this ARN by calling
CreateScan, ListScans, or GetScan.
- `tags`: An array of key-value pairs used to tag an existing scan. A tag is a custom
attribute label with two parts: A tag key. For example, CostCenter, Environment, or
Secret. Tag keys are case sensitive. An optional tag value field. For example,
111122223333, Production, or a team name. Omitting the tag value is the same as using an
empty string. Tag values are case sensitive.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return codeguru_security(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Use to remove one or more tags from an existing scan.
# Arguments
- `resource_arn`: The ARN of the ScanName object. You can retrieve this ARN by calling
CreateScan, ListScans, or GetScan.
- `tag_keys`: A list of keys for each tag you want to remove from a scan.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_account_configuration(encryption_config)
update_account_configuration(encryption_config, params::Dict{String,<:Any})
Use to update the encryption configuration for an account.
# Arguments
- `encryption_config`: The customer-managed KMS key ARN you want to use for encryption. If
not specified, CodeGuru Security will use an AWS-managed key for encryption. If you
previously specified a customer-managed KMS key and want CodeGuru Security to use an
AWS-managed key for encryption instead, pass nothing.
"""
function update_account_configuration(
encryptionConfig; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguru_security(
"PUT",
"/updateAccountConfiguration",
Dict{String,Any}("encryptionConfig" => encryptionConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_account_configuration(
encryptionConfig,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguru_security(
"PUT",
"/updateAccountConfiguration",
Dict{String,Any}(
mergewith(
_merge, Dict{String,Any}("encryptionConfig" => encryptionConfig), params
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 45994 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codeguruprofiler
using AWS.Compat
using AWS.UUIDs
"""
add_notification_channels(channels, profiling_group_name)
add_notification_channels(channels, profiling_group_name, params::Dict{String,<:Any})
Add up to 2 anomaly notifications channels for a profiling group.
# Arguments
- `channels`: One or 2 channels to report to when anomalies are detected.
- `profiling_group_name`: The name of the profiling group that we are setting up
notifications for.
"""
function add_notification_channels(
channels, profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration",
Dict{String,Any}("channels" => channels);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function add_notification_channels(
channels,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("channels" => channels), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
batch_get_frame_metric_data(profiling_group_name)
batch_get_frame_metric_data(profiling_group_name, params::Dict{String,<:Any})
Returns the time series of values for a requested list of frame metrics from a time period.
# Arguments
- `profiling_group_name`: The name of the profiling group associated with the the frame
metrics used to return the time series values.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"endTime"`: The end time of the time period for the returned time series values. This
is specified using the ISO 8601 format. For example, 2020-06-01T13:15:02.001Z represents 1
millisecond past June 1, 2020 1:15:02 PM UTC.
- `"frameMetrics"`: The details of the metrics that are used to request a time series of
values. The metric includes the name of the frame, the aggregation type to calculate the
metric value for the frame, and the thread states to use to get the count for the metric
value of the frame.
- `"period"`: The duration of the frame metrics used to return the time series values.
Specify using the ISO 8601 format. The maximum period duration is one day (PT24H or P1D).
- `"startTime"`: The start time of the time period for the frame metrics used to return
the time series values. This is specified using the ISO 8601 format. For example,
2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM UTC.
- `"targetResolution"`: The requested resolution of time steps for the returned time series
of values. If the requested target resolution is not available due to data not being
retained we provide a best effort result by falling back to the most granular available
resolution after the target resolution. There are 3 valid values. P1D — 1 day
PT1H — 1 hour PT5M — 5 minutes
"""
function batch_get_frame_metric_data(
profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/frames/-/metrics";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function batch_get_frame_metric_data(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/frames/-/metrics",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
configure_agent(profiling_group_name)
configure_agent(profiling_group_name, params::Dict{String,<:Any})
Used by profiler agents to report their current state and to receive remote configuration
updates. For example, ConfigureAgent can be used to tell an agent whether to profile or not
and for how long to return profiling data.
# Arguments
- `profiling_group_name`: The name of the profiling group for which the configured agent
is collecting profiling data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"fleetInstanceId"`: A universally unique identifier (UUID) for a profiling instance.
For example, if the profiling instance is an Amazon EC2 instance, it is the instance ID. If
it is an AWS Fargate container, it is the container's task ID.
- `"metadata"`: Metadata captured about the compute platform the agent is running on. It
includes information about sampling and reporting. The valid fields are:
COMPUTE_PLATFORM - The compute platform on which the agent is running AGENT_ID - The ID
for an agent instance. AWS_REQUEST_ID - The AWS request ID of a Lambda invocation.
EXECUTION_ENVIRONMENT - The execution environment a Lambda function is running on.
LAMBDA_FUNCTION_ARN - The Amazon Resource Name (ARN) that is used to invoke a Lambda
function. LAMBDA_MEMORY_LIMIT_IN_MB - The memory allocated to a Lambda function.
LAMBDA_REMAINING_TIME_IN_MILLISECONDS - The time in milliseconds before execution of a
Lambda function times out. LAMBDA_TIME_GAP_BETWEEN_INVOKES_IN_MILLISECONDS - The time
in milliseconds between two invocations of a Lambda function.
LAMBDA_PREVIOUS_EXECUTION_TIME_IN_MILLISECONDS - The time in milliseconds for the previous
Lambda invocation.
"""
function configure_agent(
profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/configureAgent";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function configure_agent(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/configureAgent",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_profiling_group(client_token, profiling_group_name)
create_profiling_group(client_token, profiling_group_name, params::Dict{String,<:Any})
Creates a profiling group.
# Arguments
- `client_token`: Amazon CodeGuru Profiler uses this universally unique identifier (UUID)
to prevent the accidental creation of duplicate profiling groups if there are failures and
retries.
- `profiling_group_name`: The name of the profiling group to create.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"agentOrchestrationConfig"`: Specifies whether profiling is enabled or disabled for the
created profiling group.
- `"computePlatform"`: The compute platform of the profiling group. Use AWSLambda if your
application runs on AWS Lambda. Use Default if your application runs on a compute platform
that is not AWS Lambda, such an Amazon EC2 instance, an on-premises server, or a different
platform. If not specified, Default is used.
- `"tags"`: A list of tags to add to the created profiling group.
"""
function create_profiling_group(
clientToken, profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"POST",
"/profilingGroups",
Dict{String,Any}(
"clientToken" => clientToken, "profilingGroupName" => profilingGroupName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_profiling_group(
clientToken,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"clientToken" => clientToken, "profilingGroupName" => profilingGroupName
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_profiling_group(profiling_group_name)
delete_profiling_group(profiling_group_name, params::Dict{String,<:Any})
Deletes a profiling group.
# Arguments
- `profiling_group_name`: The name of the profiling group to delete.
"""
function delete_profiling_group(
profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_profiling_group(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
describe_profiling_group(profiling_group_name)
describe_profiling_group(profiling_group_name, params::Dict{String,<:Any})
Returns a ProfilingGroupDescription object that contains information about the requested
profiling group.
# Arguments
- `profiling_group_name`: The name of the profiling group to get information about.
"""
function describe_profiling_group(
profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function describe_profiling_group(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_findings_report_account_summary()
get_findings_report_account_summary(params::Dict{String,<:Any})
Returns a list of FindingsReportSummary objects that contain analysis results for all
profiling groups in your AWS account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"dailyReportsOnly"`: A Boolean value indicating whether to only return reports from
daily profiles. If set to True, only analysis data from daily profiles is returned. If set
to False, analysis data is returned from smaller time windows (for example, one hour).
- `"maxResults"`: The maximum number of results returned by
GetFindingsReportAccountSummary in paginated output. When this parameter is used,
GetFindingsReportAccountSummary only returns maxResults results in a single page along with
a nextToken response element. The remaining results of the initial request can be seen by
sending another GetFindingsReportAccountSummary request with the returned nextToken value.
- `"nextToken"`: The nextToken value returned from a previous paginated
GetFindingsReportAccountSummary request where maxResults was used and the results exceeded
the value of that parameter. Pagination continues from the end of the previous results that
returned the nextToken value. This token should be treated as an opaque identifier that
is only used to retrieve the next items in a list and not for other programmatic purposes.
"""
function get_findings_report_account_summary(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/internal/findingsReports";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_findings_report_account_summary(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/internal/findingsReports",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_notification_configuration(profiling_group_name)
get_notification_configuration(profiling_group_name, params::Dict{String,<:Any})
Get the current configuration for anomaly notifications for a profiling group.
# Arguments
- `profiling_group_name`: The name of the profiling group we want to get the notification
configuration for.
"""
function get_notification_configuration(
profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_notification_configuration(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_policy(profiling_group_name)
get_policy(profiling_group_name, params::Dict{String,<:Any})
Returns the JSON-formatted resource-based policy on a profiling group.
# Arguments
- `profiling_group_name`: The name of the profiling group.
"""
function get_policy(profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config())
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/policy";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_policy(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/policy",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_profile(profiling_group_name)
get_profile(profiling_group_name, params::Dict{String,<:Any})
Gets the aggregated profile of a profiling group for a specified time range. Amazon
CodeGuru Profiler collects posted agent profiles for a profiling group into aggregated
profiles. <note> <p> Because aggregated profiles expire over time
<code>GetProfile</code> is not idempotent. </p> </note> <p>
Specify the time range for the requested aggregated profile using 1 or 2 of the following
parameters: <code>startTime</code>, <code>endTime</code>,
<code>period</code>. The maximum time range allowed is 7 days. If you specify
all 3 parameters, an exception is thrown. If you specify only
<code>period</code>, the latest aggregated profile is returned. </p>
<p> Aggregated profiles are available with aggregation periods of 5 minutes, 1 hour,
and 1 day, aligned to UTC. The aggregation period of an aggregated profile determines how
long it is retained. For more information, see <a
href="https://docs.aws.amazon.com/codeguru/latest/profiler-api/API_AggregatedProfileTim
e.html"> <code>AggregatedProfileTime</code> </a>. The aggregated
profile's aggregation period determines how long it is retained by CodeGuru Profiler.
</p> <ul> <li> <p> If the aggregation period is 5 minutes, the
aggregated profile is retained for 15 days. </p> </li> <li> <p> If
the aggregation period is 1 hour, the aggregated profile is retained for 60 days.
</p> </li> <li> <p> If the aggregation period is 1 day, the
aggregated profile is retained for 3 years. </p> </li> </ul>
<p>There are two use cases for calling <code>GetProfile</code>.</p>
<ol> <li> <p> If you want to return an aggregated profile that already
exists, use <a
href="https://docs.aws.amazon.com/codeguru/latest/profiler-api/API_ListProfileTimes.htm
l"> <code>ListProfileTimes</code> </a> to view the time ranges of
existing aggregated profiles. Use them in a <code>GetProfile</code> request to
return a specific, existing aggregated profile. </p> </li> <li> <p>
If you want to return an aggregated profile for a time range that doesn't align with an
existing aggregated profile, then CodeGuru Profiler makes a best effort to combine existing
aggregated profiles from the requested time range and return them as one aggregated
profile. </p> <p> If aggregated profiles do not exist for the full time range
requested, then aggregated profiles for a smaller time range are returned. For example, if
the requested time range is from 00:00 to 00:20, and the existing aggregated profiles are
from 00:15 and 00:25, then the aggregated profiles from 00:15 to 00:20 are returned.
</p> </li> </ol>
# Arguments
- `profiling_group_name`: The name of the profiling group to get.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Accept"`: The format of the returned profiling data. The format maps to the Accept and
Content-Type headers of the HTTP request. You can specify one of the following: or the
default . <ul> <li> <p> <code>application/json</code> —
standard JSON format </p> </li> <li> <p>
<code>application/x-amzn-ion</code> — the Amazon Ion data format. For more
information, see <a href="http://amzn.github.io/ion-docs/">Amazon
Ion</a>. </p> </li> </ul>
- `"endTime"`: The end time of the requested profile. Specify using the ISO 8601 format.
For example, 2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM
UTC. If you specify endTime, then you must also specify period or startTime, but not
both.
- `"maxDepth"`: The maximum depth of the stacks in the code that is represented in the
aggregated profile. For example, if CodeGuru Profiler finds a method A, which calls method
B, which calls method C, which calls method D, then the depth is 4. If the maxDepth is set
to 2, then the aggregated profile contains representations of methods A and B.
- `"period"`: Used with startTime or endTime to specify the time range for the returned
aggregated profile. Specify using the ISO 8601 format. For example, P1DT1H1M1S. <p>
To get the latest aggregated profile, specify only <code>period</code>.
</p>
- `"startTime"`: The start time of the profile to get. Specify using the ISO 8601 format.
For example, 2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM
UTC. <p> If you specify <code>startTime</code>, then you must also
specify <code>period</code> or <code>endTime</code>, but not both.
</p>
"""
function get_profile(profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config())
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/profile";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_profile(
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/profile",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_recommendations(end_time, profiling_group_name, start_time)
get_recommendations(end_time, profiling_group_name, start_time, params::Dict{String,<:Any})
Returns a list of Recommendation objects that contain recommendations for a profiling
group for a given time period. A list of Anomaly objects that contains details about
anomalies detected in the profiling group for the same time period is also returned.
# Arguments
- `end_time`: The start time of the profile to get analysis data about. You must specify
startTime and endTime. This is specified using the ISO 8601 format. For example,
2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM UTC.
- `profiling_group_name`: The name of the profiling group to get analysis data about.
- `start_time`: The end time of the profile to get analysis data about. You must specify
startTime and endTime. This is specified using the ISO 8601 format. For example,
2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM UTC.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"locale"`: The language used to provide analysis. Specify using a string that is one of
the following BCP 47 language codes. de-DE - German, Germany en-GB - English,
United Kingdom en-US - English, United States es-ES - Spanish, Spain fr-FR -
French, France it-IT - Italian, Italy ja-JP - Japanese, Japan ko-KR - Korean,
Republic of Korea pt-BR - Portugese, Brazil zh-CN - Chinese, China zh-TW -
Chinese, Taiwan
"""
function get_recommendations(
endTime,
profilingGroupName,
startTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/internal/profilingGroups/$(profilingGroupName)/recommendations",
Dict{String,Any}("endTime" => endTime, "startTime" => startTime);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_recommendations(
endTime,
profilingGroupName,
startTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/internal/profilingGroups/$(profilingGroupName)/recommendations",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("endTime" => endTime, "startTime" => startTime),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_findings_reports(end_time, profiling_group_name, start_time)
list_findings_reports(end_time, profiling_group_name, start_time, params::Dict{String,<:Any})
List the available reports for a given profiling group and time range.
# Arguments
- `end_time`: The end time of the profile to get analysis data about. You must specify
startTime and endTime. This is specified using the ISO 8601 format. For example,
2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM UTC.
- `profiling_group_name`: The name of the profiling group from which to search for analysis
data.
- `start_time`: The start time of the profile to get analysis data about. You must specify
startTime and endTime. This is specified using the ISO 8601 format. For example,
2020-06-01T13:15:02.001Z represents 1 millisecond past June 1, 2020 1:15:02 PM UTC.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"dailyReportsOnly"`: A Boolean value indicating whether to only return reports from
daily profiles. If set to True, only analysis data from daily profiles is returned. If set
to False, analysis data is returned from smaller time windows (for example, one hour).
- `"maxResults"`: The maximum number of report results returned by ListFindingsReports in
paginated output. When this parameter is used, ListFindingsReports only returns maxResults
results in a single page along with a nextToken response element. The remaining results of
the initial request can be seen by sending another ListFindingsReports request with the
returned nextToken value.
- `"nextToken"`: The nextToken value returned from a previous paginated
ListFindingsReportsRequest request where maxResults was used and the results exceeded the
value of that parameter. Pagination continues from the end of the previous results that
returned the nextToken value. This token should be treated as an opaque identifier that
is only used to retrieve the next items in a list and not for other programmatic purposes.
"""
function list_findings_reports(
endTime,
profilingGroupName,
startTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/internal/profilingGroups/$(profilingGroupName)/findingsReports",
Dict{String,Any}("endTime" => endTime, "startTime" => startTime);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_findings_reports(
endTime,
profilingGroupName,
startTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/internal/profilingGroups/$(profilingGroupName)/findingsReports",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("endTime" => endTime, "startTime" => startTime),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_profile_times(end_time, period, profiling_group_name, start_time)
list_profile_times(end_time, period, profiling_group_name, start_time, params::Dict{String,<:Any})
Lists the start times of the available aggregated profiles of a profiling group for an
aggregation period within the specified time range.
# Arguments
- `end_time`: The end time of the time range from which to list the profiles.
- `period`: The aggregation period. This specifies the period during which an aggregation
profile collects posted agent profiles for a profiling group. There are 3 valid values.
P1D — 1 day PT1H — 1 hour PT5M — 5 minutes
- `profiling_group_name`: The name of the profiling group.
- `start_time`: The start time of the time range from which to list the profiles.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of profile time results returned by ListProfileTimes
in paginated output. When this parameter is used, ListProfileTimes only returns maxResults
results in a single page with a nextToken response element. The remaining results of the
initial request can be seen by sending another ListProfileTimes request with the returned
nextToken value.
- `"nextToken"`: The nextToken value returned from a previous paginated ListProfileTimes
request where maxResults was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken
value. This token should be treated as an opaque identifier that is only used to retrieve
the next items in a list and not for other programmatic purposes.
- `"orderBy"`: The order (ascending or descending by start time of the profile) to use when
listing profiles. Defaults to TIMESTAMP_DESCENDING.
"""
function list_profile_times(
endTime,
period,
profilingGroupName,
startTime;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/profileTimes",
Dict{String,Any}(
"endTime" => endTime, "period" => period, "startTime" => startTime
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_profile_times(
endTime,
period,
profilingGroupName,
startTime,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/profilingGroups/$(profilingGroupName)/profileTimes",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"endTime" => endTime, "period" => period, "startTime" => startTime
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_profiling_groups()
list_profiling_groups(params::Dict{String,<:Any})
Returns a list of profiling groups. The profiling groups are returned as
ProfilingGroupDescription objects.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"includeDescription"`: A Boolean value indicating whether to include a description. If
true, then a list of ProfilingGroupDescription objects that contain detailed information
about profiling groups is returned. If false, then a list of profiling group names is
returned.
- `"maxResults"`: The maximum number of profiling groups results returned by
ListProfilingGroups in paginated output. When this parameter is used, ListProfilingGroups
only returns maxResults results in a single page along with a nextToken response element.
The remaining results of the initial request can be seen by sending another
ListProfilingGroups request with the returned nextToken value.
- `"nextToken"`: The nextToken value returned from a previous paginated ListProfilingGroups
request where maxResults was used and the results exceeded the value of that parameter.
Pagination continues from the end of the previous results that returned the nextToken
value. This token should be treated as an opaque identifier that is only used to retrieve
the next items in a list and not for other programmatic purposes.
"""
function list_profiling_groups(; aws_config::AbstractAWSConfig=global_aws_config())
return codeguruprofiler(
"GET", "/profilingGroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_profiling_groups(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/profilingGroups",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Returns a list of the tags that are assigned to a specified resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that contains the tags to
return.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"GET",
"/tags/$(resourceArn)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"GET",
"/tags/$(resourceArn)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
post_agent_profile(content-_type, agent_profile, profiling_group_name)
post_agent_profile(content-_type, agent_profile, profiling_group_name, params::Dict{String,<:Any})
Submits profiling data to an aggregated profile of a profiling group. To get an aggregated
profile that is created with this profiling data, use GetProfile .
# Arguments
- `content-_type`: The format of the submitted profiling data. The format maps to the
Accept and Content-Type headers of the HTTP request. You can specify one of the following:
or the default . <ul> <li> <p>
<code>application/json</code> — standard JSON format </p> </li>
<li> <p> <code>application/x-amzn-ion</code> — the Amazon Ion
data format. For more information, see <a
href="http://amzn.github.io/ion-docs/">Amazon Ion</a>. </p>
</li> </ul>
- `agent_profile`: The submitted profiling data.
- `profiling_group_name`: The name of the profiling group with the aggregated profile that
receives the submitted profiling data.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"profileToken"`: Amazon CodeGuru Profiler uses this universally unique identifier
(UUID) to prevent the accidental submission of duplicate profiling data if there are
failures and retries.
"""
function post_agent_profile(
Content_Type,
agentProfile,
profilingGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/agentProfile",
Dict{String,Any}(
"agentProfile" => agentProfile,
"profileToken" => string(uuid4()),
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function post_agent_profile(
Content_Type,
agentProfile,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/profilingGroups/$(profilingGroupName)/agentProfile",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"agentProfile" => agentProfile,
"profileToken" => string(uuid4()),
"headers" => Dict{String,Any}("Content-Type" => Content_Type),
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_permission(action_group, principals, profiling_group_name)
put_permission(action_group, principals, profiling_group_name, params::Dict{String,<:Any})
Adds permissions to a profiling group's resource-based policy that are provided using an
action group. If a profiling group doesn't have a resource-based policy, one is created for
it using the permissions in the action group and the roles and users in the principals
parameter. <p> The one supported action group that can be added is
<code>agentPermission</code> which grants
<code>ConfigureAgent</code> and <code>PostAgent</code> permissions.
For more information, see <a
href="https://docs.aws.amazon.com/codeguru/latest/profiler-ug/resource-based-policies.h
tml">Resource-based policies in CodeGuru Profiler</a> in the <i>Amazon
CodeGuru Profiler User Guide</i>, <a
href="https://docs.aws.amazon.com/codeguru/latest/profiler-api/API_ConfigureAgent.html
"> <code>ConfigureAgent</code> </a>, and <a
href="https://docs.aws.amazon.com/codeguru/latest/profiler-api/API_PostAgentProfile.htm
l"> <code>PostAgentProfile</code> </a>. </p> <p> The
first time you call <code>PutPermission</code> on a profiling group, do not
specify a <code>revisionId</code> because it doesn't have a resource-based
policy. Subsequent calls must provide a <code>revisionId</code> to specify
which revision of the resource-based policy to add the permissions to. </p> <p>
The response contains the profiling group's JSON-formatted resource policy. </p>
# Arguments
- `action_group`: Specifies an action group that contains permissions to add to a
profiling group resource. One action group is supported, agentPermissions, which grants
permission to perform actions required by the profiling agent, ConfigureAgent and
PostAgentProfile permissions.
- `principals`: A list ARNs for the roles and users you want to grant access to the
profiling group. Wildcards are not are supported in the ARNs.
- `profiling_group_name`: The name of the profiling group to grant access to.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"revisionId"`: A universally unique identifier (UUID) for the revision of the policy
you are adding to the profiling group. Do not specify this when you add permissions to a
profiling group for the first time. If a policy already exists on the profiling group, you
must specify the revisionId.
"""
function put_permission(
actionGroup,
principals,
profilingGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"PUT",
"/profilingGroups/$(profilingGroupName)/policy/$(actionGroup)",
Dict{String,Any}("principals" => principals);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_permission(
actionGroup,
principals,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"PUT",
"/profilingGroups/$(profilingGroupName)/policy/$(actionGroup)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("principals" => principals), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_notification_channel(channel_id, profiling_group_name)
remove_notification_channel(channel_id, profiling_group_name, params::Dict{String,<:Any})
Remove one anomaly notifications channel for a profiling group.
# Arguments
- `channel_id`: The id of the channel that we want to stop receiving notifications.
- `profiling_group_name`: The name of the profiling group we want to change notification
configuration for.
"""
function remove_notification_channel(
channelId, profilingGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration/$(channelId)";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_notification_channel(
channelId,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)/notificationConfiguration/$(channelId)",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
remove_permission(action_group, profiling_group_name, revision_id)
remove_permission(action_group, profiling_group_name, revision_id, params::Dict{String,<:Any})
Removes permissions from a profiling group's resource-based policy that are provided using
an action group. The one supported action group that can be removed is agentPermission
which grants ConfigureAgent and PostAgent permissions. For more information, see
Resource-based policies in CodeGuru Profiler in the Amazon CodeGuru Profiler User Guide,
ConfigureAgent , and PostAgentProfile .
# Arguments
- `action_group`: Specifies an action group that contains the permissions to remove from a
profiling group's resource-based policy. One action group is supported, agentPermissions,
which grants ConfigureAgent and PostAgentProfile permissions.
- `profiling_group_name`: The name of the profiling group.
- `revision_id`: A universally unique identifier (UUID) for the revision of the
resource-based policy from which you want to remove permissions.
"""
function remove_permission(
actionGroup,
profilingGroupName,
revisionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)/policy/$(actionGroup)",
Dict{String,Any}("revisionId" => revisionId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function remove_permission(
actionGroup,
profilingGroupName,
revisionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"DELETE",
"/profilingGroups/$(profilingGroupName)/policy/$(actionGroup)",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("revisionId" => revisionId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
submit_feedback(anomaly_instance_id, profiling_group_name, type)
submit_feedback(anomaly_instance_id, profiling_group_name, type, params::Dict{String,<:Any})
Sends feedback to CodeGuru Profiler about whether the anomaly detected by the analysis is
useful or not.
# Arguments
- `anomaly_instance_id`: The universally unique identifier (UUID) of the AnomalyInstance
object that is included in the analysis data.
- `profiling_group_name`: The name of the profiling group that is associated with the
analysis data.
- `type`: The feedback tpye. Thee are two valid values, Positive and Negative.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"comment"`: Optional feedback about this anomaly.
"""
function submit_feedback(
anomalyInstanceId,
profilingGroupName,
type;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/internal/profilingGroups/$(profilingGroupName)/anomalies/$(anomalyInstanceId)/feedback",
Dict{String,Any}("type" => type);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function submit_feedback(
anomalyInstanceId,
profilingGroupName,
type,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/internal/profilingGroups/$(profilingGroupName)/anomalies/$(anomalyInstanceId)/feedback",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("type" => type), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Use to assign one or more tags to a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that the tags are added
to.
- `tags`: The list of tags that are added to the specified resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return codeguruprofiler(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}("tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"POST",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Use to remove one or more tags from a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource that contains the tags to
remove.
- `tag_keys`: A list of tag keys. Existing tags of resources with keys in this list are
removed from the specified resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codeguruprofiler(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}("tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"DELETE",
"/tags/$(resourceArn)",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_profiling_group(agent_orchestration_config, profiling_group_name)
update_profiling_group(agent_orchestration_config, profiling_group_name, params::Dict{String,<:Any})
Updates a profiling group.
# Arguments
- `agent_orchestration_config`: Specifies whether profiling is enabled or disabled for a
profiling group.
- `profiling_group_name`: The name of the profiling group to update.
"""
function update_profiling_group(
agentOrchestrationConfig,
profilingGroupName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"PUT",
"/profilingGroups/$(profilingGroupName)",
Dict{String,Any}("agentOrchestrationConfig" => agentOrchestrationConfig);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_profiling_group(
agentOrchestrationConfig,
profilingGroupName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codeguruprofiler(
"PUT",
"/profilingGroups/$(profilingGroupName)",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("agentOrchestrationConfig" => agentOrchestrationConfig),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
|
[
"MIT"
] | 1.92.0 | 319ade7f8fc88243369e119859a7d3a3e7e7f267 | code | 62256 | # This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: codepipeline
using AWS.Compat
using AWS.UUIDs
"""
acknowledge_job(job_id, nonce)
acknowledge_job(job_id, nonce, params::Dict{String,<:Any})
Returns information about a specified job and whether that job has been received by the job
worker. Used for custom actions only.
# Arguments
- `job_id`: The unique system-generated ID of the job for which you want to confirm receipt.
- `nonce`: A system-generated random number that CodePipeline uses to ensure that the job
is being worked on by only one job worker. Get this number from the response of the
PollForJobs request that returned this job.
"""
function acknowledge_job(jobId, nonce; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"AcknowledgeJob",
Dict{String,Any}("jobId" => jobId, "nonce" => nonce);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function acknowledge_job(
jobId,
nonce,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"AcknowledgeJob",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("jobId" => jobId, "nonce" => nonce), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
acknowledge_third_party_job(client_token, job_id, nonce)
acknowledge_third_party_job(client_token, job_id, nonce, params::Dict{String,<:Any})
Confirms a job worker has received the specified job. Used for partner actions only.
# Arguments
- `client_token`: The clientToken portion of the clientId and clientToken pair used to
verify that the calling entity is allowed access to the job and its details.
- `job_id`: The unique system-generated ID of the job.
- `nonce`: A system-generated random number that CodePipeline uses to ensure that the job
is being worked on by only one job worker. Get this number from the response to a
GetThirdPartyJobDetails request.
"""
function acknowledge_third_party_job(
clientToken, jobId, nonce; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"AcknowledgeThirdPartyJob",
Dict{String,Any}("clientToken" => clientToken, "jobId" => jobId, "nonce" => nonce);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function acknowledge_third_party_job(
clientToken,
jobId,
nonce,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"AcknowledgeThirdPartyJob",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"clientToken" => clientToken, "jobId" => jobId, "nonce" => nonce
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_custom_action_type(category, input_artifact_details, output_artifact_details, provider, version)
create_custom_action_type(category, input_artifact_details, output_artifact_details, provider, version, params::Dict{String,<:Any})
Creates a new custom action that can be used in all pipelines associated with the Amazon
Web Services account. Only used for custom actions.
# Arguments
- `category`: The category of the custom action, such as a build action or a test action.
- `input_artifact_details`: The details of the input artifact for the action, such as its
commit ID.
- `output_artifact_details`: The details of the output artifact of the action, such as its
commit ID.
- `provider`: The provider of the service used in the custom action, such as CodeDeploy.
- `version`: The version identifier of the custom action.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"configurationProperties"`: The configuration properties for the custom action. You can
refer to a name in the configuration properties of the custom action within the URL
templates by following the format of {Config:name}, as long as the configuration property
is both required and not secret. For more information, see Create a Custom Action for a
Pipeline.
- `"settings"`: URLs that provide users information about this custom action.
- `"tags"`: The tags for the custom action.
"""
function create_custom_action_type(
category,
inputArtifactDetails,
outputArtifactDetails,
provider,
version;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"CreateCustomActionType",
Dict{String,Any}(
"category" => category,
"inputArtifactDetails" => inputArtifactDetails,
"outputArtifactDetails" => outputArtifactDetails,
"provider" => provider,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_custom_action_type(
category,
inputArtifactDetails,
outputArtifactDetails,
provider,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"CreateCustomActionType",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"category" => category,
"inputArtifactDetails" => inputArtifactDetails,
"outputArtifactDetails" => outputArtifactDetails,
"provider" => provider,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
create_pipeline(pipeline)
create_pipeline(pipeline, params::Dict{String,<:Any})
Creates a pipeline. In the pipeline structure, you must include either artifactStore or
artifactStores in your pipeline, but you cannot use both. If you create a cross-region
action in your pipeline, you must use artifactStores.
# Arguments
- `pipeline`: Represents the structure of actions and stages to be performed in the
pipeline.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: The tags for the pipeline.
"""
function create_pipeline(pipeline; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"CreatePipeline",
Dict{String,Any}("pipeline" => pipeline);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function create_pipeline(
pipeline,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"CreatePipeline",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pipeline" => pipeline), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_custom_action_type(category, provider, version)
delete_custom_action_type(category, provider, version, params::Dict{String,<:Any})
Marks a custom action as deleted. PollForJobs for the custom action fails after the action
is marked for deletion. Used for custom actions only. To re-create a custom action after
it has been deleted you must use a string in the version field that has never been used
before. This string can be an incremented version number, for example. To restore a deleted
custom action, use a JSON file that is identical to the deleted action, including the
original string in the version field.
# Arguments
- `category`: The category of the custom action that you want to delete, such as source or
deploy.
- `provider`: The provider of the service used in the custom action, such as CodeDeploy.
- `version`: The version of the custom action to delete.
"""
function delete_custom_action_type(
category, provider, version; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"DeleteCustomActionType",
Dict{String,Any}(
"category" => category, "provider" => provider, "version" => version
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_custom_action_type(
category,
provider,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"DeleteCustomActionType",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"category" => category, "provider" => provider, "version" => version
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_pipeline(name)
delete_pipeline(name, params::Dict{String,<:Any})
Deletes the specified pipeline.
# Arguments
- `name`: The name of the pipeline to be deleted.
"""
function delete_pipeline(name; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"DeletePipeline",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_pipeline(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"DeletePipeline",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
delete_webhook(name)
delete_webhook(name, params::Dict{String,<:Any})
Deletes a previously created webhook by name. Deleting the webhook stops CodePipeline from
starting a pipeline every time an external event occurs. The API returns successfully when
trying to delete a webhook that is already deleted. If a deleted webhook is re-created by
calling PutWebhook with the same name, it will have a different URL.
# Arguments
- `name`: The name of the webhook you want to delete.
"""
function delete_webhook(name; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"DeleteWebhook",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function delete_webhook(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"DeleteWebhook",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
deregister_webhook_with_third_party()
deregister_webhook_with_third_party(params::Dict{String,<:Any})
Removes the connection between the webhook that was created by CodePipeline and the
external tool with events to be detected. Currently supported only for webhooks that target
an action type of GitHub.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"webhookName"`: The name of the webhook you want to deregister.
"""
function deregister_webhook_with_third_party(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"DeregisterWebhookWithThirdParty";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function deregister_webhook_with_third_party(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"DeregisterWebhookWithThirdParty",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
disable_stage_transition(pipeline_name, reason, stage_name, transition_type)
disable_stage_transition(pipeline_name, reason, stage_name, transition_type, params::Dict{String,<:Any})
Prevents artifacts in a pipeline from transitioning to the next stage in the pipeline.
# Arguments
- `pipeline_name`: The name of the pipeline in which you want to disable the flow of
artifacts from one stage to another.
- `reason`: The reason given to the user that a stage is disabled, such as waiting for
manual approval or manual tests. This message is displayed in the pipeline console UI.
- `stage_name`: The name of the stage where you want to disable the inbound or outbound
transition of artifacts.
- `transition_type`: Specifies whether artifacts are prevented from transitioning into the
stage and being processed by the actions in that stage (inbound), or prevented from
transitioning from the stage after they have been processed by the actions in that stage
(outbound).
"""
function disable_stage_transition(
pipelineName,
reason,
stageName,
transitionType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"DisableStageTransition",
Dict{String,Any}(
"pipelineName" => pipelineName,
"reason" => reason,
"stageName" => stageName,
"transitionType" => transitionType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function disable_stage_transition(
pipelineName,
reason,
stageName,
transitionType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"DisableStageTransition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineName" => pipelineName,
"reason" => reason,
"stageName" => stageName,
"transitionType" => transitionType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
enable_stage_transition(pipeline_name, stage_name, transition_type)
enable_stage_transition(pipeline_name, stage_name, transition_type, params::Dict{String,<:Any})
Enables artifacts in a pipeline to transition to a stage in a pipeline.
# Arguments
- `pipeline_name`: The name of the pipeline in which you want to enable the flow of
artifacts from one stage to another.
- `stage_name`: The name of the stage where you want to enable the transition of artifacts,
either into the stage (inbound) or from that stage to the next stage (outbound).
- `transition_type`: Specifies whether artifacts are allowed to enter the stage and be
processed by the actions in that stage (inbound) or whether already processed artifacts are
allowed to transition to the next stage (outbound).
"""
function enable_stage_transition(
pipelineName,
stageName,
transitionType;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"EnableStageTransition",
Dict{String,Any}(
"pipelineName" => pipelineName,
"stageName" => stageName,
"transitionType" => transitionType,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function enable_stage_transition(
pipelineName,
stageName,
transitionType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"EnableStageTransition",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineName" => pipelineName,
"stageName" => stageName,
"transitionType" => transitionType,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_action_type(category, owner, provider, version)
get_action_type(category, owner, provider, version, params::Dict{String,<:Any})
Returns information about an action type created for an external provider, where the action
is to be used by customers of the external provider. The action can be created with any
supported integration model.
# Arguments
- `category`: Defines what kind of action can be taken in the stage. The following are the
valid values: Source Build Test Deploy Approval Invoke
- `owner`: The creator of an action type that was created with any supported integration
model. There are two valid values: AWS and ThirdParty.
- `provider`: The provider of the action type being called. The provider name is specified
when the action type is created.
- `version`: A string that describes the action type version.
"""
function get_action_type(
category, owner, provider, version; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetActionType",
Dict{String,Any}(
"category" => category,
"owner" => owner,
"provider" => provider,
"version" => version,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_action_type(
category,
owner,
provider,
version,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"GetActionType",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"category" => category,
"owner" => owner,
"provider" => provider,
"version" => version,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_job_details(job_id)
get_job_details(job_id, params::Dict{String,<:Any})
Returns information about a job. Used for custom actions only. When this API is called,
CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for
the pipeline, if the action requires access to that S3 bucket for input or output
artifacts. This API also returns any secret values defined for the action.
# Arguments
- `job_id`: The unique system-generated ID for the job.
"""
function get_job_details(jobId; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"GetJobDetails",
Dict{String,Any}("jobId" => jobId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_job_details(
jobId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetJobDetails",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("jobId" => jobId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pipeline(name)
get_pipeline(name, params::Dict{String,<:Any})
Returns the metadata, structure, stages, and actions of a pipeline. Can be used to return
the entire structure of a pipeline in JSON format, which can then be modified and used to
update the pipeline structure with UpdatePipeline.
# Arguments
- `name`: The name of the pipeline for which you want to get information. Pipeline names
must be unique in an Amazon Web Services account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"version"`: The version number of the pipeline. If you do not specify a version,
defaults to the current version.
"""
function get_pipeline(name; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"GetPipeline",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pipeline(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetPipeline",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pipeline_execution(pipeline_execution_id, pipeline_name)
get_pipeline_execution(pipeline_execution_id, pipeline_name, params::Dict{String,<:Any})
Returns information about an execution of a pipeline, including details about artifacts,
the pipeline execution ID, and the name, version, and status of the pipeline.
# Arguments
- `pipeline_execution_id`: The ID of the pipeline execution about which you want to get
execution details.
- `pipeline_name`: The name of the pipeline about which you want to get execution details.
"""
function get_pipeline_execution(
pipelineExecutionId, pipelineName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetPipelineExecution",
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId, "pipelineName" => pipelineName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pipeline_execution(
pipelineExecutionId,
pipelineName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"GetPipelineExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId,
"pipelineName" => pipelineName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_pipeline_state(name)
get_pipeline_state(name, params::Dict{String,<:Any})
Returns information about the state of a pipeline, including the stages and actions.
Values returned in the revisionId and revisionUrl fields indicate the source revision
information, such as the commit ID, for the current state.
# Arguments
- `name`: The name of the pipeline about which you want to get information.
"""
function get_pipeline_state(name; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"GetPipelineState",
Dict{String,Any}("name" => name);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_pipeline_state(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetPipelineState",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("name" => name), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
get_third_party_job_details(client_token, job_id)
get_third_party_job_details(client_token, job_id, params::Dict{String,<:Any})
Requests the details of a job for a third party action. Used for partner actions only.
When this API is called, CodePipeline returns temporary credentials for the S3 bucket used
to store artifacts for the pipeline, if the action requires access to that S3 bucket for
input or output artifacts. This API also returns any secret values defined for the action.
# Arguments
- `client_token`: The clientToken portion of the clientId and clientToken pair used to
verify that the calling entity is allowed access to the job and its details.
- `job_id`: The unique system-generated ID used for identifying the job.
"""
function get_third_party_job_details(
clientToken, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"GetThirdPartyJobDetails",
Dict{String,Any}("clientToken" => clientToken, "jobId" => jobId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function get_third_party_job_details(
clientToken,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"GetThirdPartyJobDetails",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("clientToken" => clientToken, "jobId" => jobId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_action_executions(pipeline_name)
list_action_executions(pipeline_name, params::Dict{String,<:Any})
Lists the action executions that have occurred in a pipeline.
# Arguments
- `pipeline_name`: The name of the pipeline for which you want to list action execution
history.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: Input information used to filter action execution history.
- `"maxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned nextToken value. Action execution
history is retained for up to 12 months, based on action execution start times. Default
value is 100.
- `"nextToken"`: The token that was returned from the previous ListActionExecutions call,
which can be used to return the next set of action executions in the list.
"""
function list_action_executions(
pipelineName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListActionExecutions",
Dict{String,Any}("pipelineName" => pipelineName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_action_executions(
pipelineName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"ListActionExecutions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pipelineName" => pipelineName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_action_types()
list_action_types(params::Dict{String,<:Any})
Gets a summary of all CodePipeline action types associated with your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"actionOwnerFilter"`: Filters the list of action types to those created by a specified
entity.
- `"nextToken"`: An identifier that was returned from the previous list action types call,
which can be used to return the next set of action types in the list.
- `"regionFilter"`: The Region to filter on for the list of action types.
"""
function list_action_types(; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"ListActionTypes"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_action_types(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListActionTypes", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_pipeline_executions(pipeline_name)
list_pipeline_executions(pipeline_name, params::Dict{String,<:Any})
Gets a summary of the most recent executions for a pipeline. When applying the filter for
pipeline executions that have succeeded in the stage, the operation returns all executions
in the current pipeline version beginning on February 1, 2024.
# Arguments
- `pipeline_name`: The name of the pipeline for which you want to get execution summary
information.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"filter"`: The pipeline execution to filter on.
- `"maxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned nextToken value. Pipeline history is
limited to the most recent 12 months, based on pipeline execution start times. Default
value is 100.
- `"nextToken"`: The token that was returned from the previous ListPipelineExecutions call,
which can be used to return the next set of pipeline executions in the list.
"""
function list_pipeline_executions(
pipelineName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListPipelineExecutions",
Dict{String,Any}("pipelineName" => pipelineName);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_pipeline_executions(
pipelineName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"ListPipelineExecutions",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pipelineName" => pipelineName), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_pipelines()
list_pipelines(params::Dict{String,<:Any})
Gets a summary of all of the pipelines associated with your account.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of pipelines to return in a single call. To retrieve
the remaining pipelines, make another call with the returned nextToken value. The minimum
value you can specify is 1. The maximum accepted value is 1000.
- `"nextToken"`: An identifier that was returned from the previous list pipelines call. It
can be used to return the next set of pipelines in the list.
"""
function list_pipelines(; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"ListPipelines"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_pipelines(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListPipelines", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
list_tags_for_resource(resource_arn)
list_tags_for_resource(resource_arn, params::Dict{String,<:Any})
Gets the set of key-value pairs (metadata) that are used to manage the resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to get tags for.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: The maximum number of results to return in a single call.
- `"nextToken"`: The token that was returned from the previous API call, which would be
used to return the next page of the list. The ListTagsforResource call lists all available
tags in one call and does not use pagination.
"""
function list_tags_for_resource(
resourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListTagsForResource",
Dict{String,Any}("resourceArn" => resourceArn);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function list_tags_for_resource(
resourceArn,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"ListTagsForResource",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("resourceArn" => resourceArn), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
list_webhooks()
list_webhooks(params::Dict{String,<:Any})
Gets a listing of all the webhooks in this Amazon Web Services Region for this account. The
output lists all webhooks and includes the webhook URL and ARN and the configuration for
each webhook.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of results to return in a single call. To retrieve the
remaining results, make another call with the returned nextToken value.
- `"NextToken"`: The token that was returned from the previous ListWebhooks call, which can
be used to return the next set of webhooks in the list.
"""
function list_webhooks(; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"ListWebhooks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
function list_webhooks(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"ListWebhooks", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
)
end
"""
poll_for_jobs(action_type_id)
poll_for_jobs(action_type_id, params::Dict{String,<:Any})
Returns information about any jobs for CodePipeline to act on. PollForJobs is valid only
for action types with \"Custom\" in the owner field. If the action type contains AWS or
ThirdParty in the owner field, the PollForJobs action returns an error. When this API is
called, CodePipeline returns temporary credentials for the S3 bucket used to store
artifacts for the pipeline, if the action requires access to that S3 bucket for input or
output artifacts. This API also returns any secret values defined for the action.
# Arguments
- `action_type_id`: Represents information about an action type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxBatchSize"`: The maximum number of jobs to return in a poll for jobs call.
- `"queryParam"`: A map of property names and values. For an action type with no queryable
properties, this value must be null or an empty map. For an action type with a queryable
property, you must supply that property as a key in the map. Only jobs whose action
configuration matches the mapped value are returned.
"""
function poll_for_jobs(actionTypeId; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"PollForJobs",
Dict{String,Any}("actionTypeId" => actionTypeId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function poll_for_jobs(
actionTypeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PollForJobs",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("actionTypeId" => actionTypeId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
poll_for_third_party_jobs(action_type_id)
poll_for_third_party_jobs(action_type_id, params::Dict{String,<:Any})
Determines whether there are any third party jobs for a job worker to act on. Used for
partner actions only. When this API is called, CodePipeline returns temporary credentials
for the S3 bucket used to store artifacts for the pipeline, if the action requires access
to that S3 bucket for input or output artifacts.
# Arguments
- `action_type_id`: Represents information about an action type.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxBatchSize"`: The maximum number of jobs to return in a poll for jobs call.
"""
function poll_for_third_party_jobs(
actionTypeId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PollForThirdPartyJobs",
Dict{String,Any}("actionTypeId" => actionTypeId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function poll_for_third_party_jobs(
actionTypeId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PollForThirdPartyJobs",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("actionTypeId" => actionTypeId), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_action_revision(action_name, action_revision, pipeline_name, stage_name)
put_action_revision(action_name, action_revision, pipeline_name, stage_name, params::Dict{String,<:Any})
Provides information to CodePipeline about new revisions to a source.
# Arguments
- `action_name`: The name of the action that processes the revision.
- `action_revision`: Represents information about the version (or revision) of an action.
- `pipeline_name`: The name of the pipeline that starts processing the revision to the
source.
- `stage_name`: The name of the stage that contains the action that acts on the revision.
"""
function put_action_revision(
actionName,
actionRevision,
pipelineName,
stageName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutActionRevision",
Dict{String,Any}(
"actionName" => actionName,
"actionRevision" => actionRevision,
"pipelineName" => pipelineName,
"stageName" => stageName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_action_revision(
actionName,
actionRevision,
pipelineName,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutActionRevision",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"actionName" => actionName,
"actionRevision" => actionRevision,
"pipelineName" => pipelineName,
"stageName" => stageName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_approval_result(action_name, pipeline_name, result, stage_name, token)
put_approval_result(action_name, pipeline_name, result, stage_name, token, params::Dict{String,<:Any})
Provides the response to a manual approval request to CodePipeline. Valid responses include
Approved and Rejected.
# Arguments
- `action_name`: The name of the action for which approval is requested.
- `pipeline_name`: The name of the pipeline that contains the action.
- `result`: Represents information about the result of the approval request.
- `stage_name`: The name of the stage that contains the action.
- `token`: The system-generated token used to identify a unique approval request. The token
for each open approval request can be obtained using the GetPipelineState action. It is
used to validate that the approval request corresponding to this token is still valid.
"""
function put_approval_result(
actionName,
pipelineName,
result,
stageName,
token;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutApprovalResult",
Dict{String,Any}(
"actionName" => actionName,
"pipelineName" => pipelineName,
"result" => result,
"stageName" => stageName,
"token" => token,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_approval_result(
actionName,
pipelineName,
result,
stageName,
token,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutApprovalResult",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"actionName" => actionName,
"pipelineName" => pipelineName,
"result" => result,
"stageName" => stageName,
"token" => token,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_job_failure_result(failure_details, job_id)
put_job_failure_result(failure_details, job_id, params::Dict{String,<:Any})
Represents the failure of a job as returned to the pipeline by a job worker. Used for
custom actions only.
# Arguments
- `failure_details`: The details about the failure of a job.
- `job_id`: The unique system-generated ID of the job that failed. This is the same ID
returned from PollForJobs.
"""
function put_job_failure_result(
failureDetails, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PutJobFailureResult",
Dict{String,Any}("failureDetails" => failureDetails, "jobId" => jobId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_job_failure_result(
failureDetails,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutJobFailureResult",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("failureDetails" => failureDetails, "jobId" => jobId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_job_success_result(job_id)
put_job_success_result(job_id, params::Dict{String,<:Any})
Represents the success of a job as returned to the pipeline by a job worker. Used for
custom actions only.
# Arguments
- `job_id`: The unique system-generated ID of the job that succeeded. This is the same ID
returned from PollForJobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"continuationToken"`: A token generated by a job worker, such as a CodeDeploy deployment
ID, that a successful job provides to identify a custom action in progress. Future jobs use
this token to identify the running instance of the action. It can be reused to return more
information about the progress of the custom action. When the action is complete, no
continuation token should be supplied.
- `"currentRevision"`: The ID of the current revision of the artifact successfully worked
on by the job.
- `"executionDetails"`: The execution details of the successful job, such as the actions
taken by the job worker.
- `"outputVariables"`: Key-value pairs produced as output by a job worker that can be made
available to a downstream action configuration. outputVariables can be included only when
there is no continuation token on the request.
"""
function put_job_success_result(jobId; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"PutJobSuccessResult",
Dict{String,Any}("jobId" => jobId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_job_success_result(
jobId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PutJobSuccessResult",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("jobId" => jobId), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_third_party_job_failure_result(client_token, failure_details, job_id)
put_third_party_job_failure_result(client_token, failure_details, job_id, params::Dict{String,<:Any})
Represents the failure of a third party job as returned to the pipeline by a job worker.
Used for partner actions only.
# Arguments
- `client_token`: The clientToken portion of the clientId and clientToken pair used to
verify that the calling entity is allowed access to the job and its details.
- `failure_details`: Represents information about failure details.
- `job_id`: The ID of the job that failed. This is the same ID returned from
PollForThirdPartyJobs.
"""
function put_third_party_job_failure_result(
clientToken, failureDetails, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PutThirdPartyJobFailureResult",
Dict{String,Any}(
"clientToken" => clientToken,
"failureDetails" => failureDetails,
"jobId" => jobId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_third_party_job_failure_result(
clientToken,
failureDetails,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutThirdPartyJobFailureResult",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"clientToken" => clientToken,
"failureDetails" => failureDetails,
"jobId" => jobId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_third_party_job_success_result(client_token, job_id)
put_third_party_job_success_result(client_token, job_id, params::Dict{String,<:Any})
Represents the success of a third party job as returned to the pipeline by a job worker.
Used for partner actions only.
# Arguments
- `client_token`: The clientToken portion of the clientId and clientToken pair used to
verify that the calling entity is allowed access to the job and its details.
- `job_id`: The ID of the job that successfully completed. This is the same ID returned
from PollForThirdPartyJobs.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"continuationToken"`: A token generated by a job worker, such as a CodeDeploy deployment
ID, that a successful job provides to identify a partner action in progress. Future jobs
use this token to identify the running instance of the action. It can be reused to return
more information about the progress of the partner action. When the action is complete, no
continuation token should be supplied.
- `"currentRevision"`: Represents information about a current revision.
- `"executionDetails"`: The details of the actions taken and results produced on an
artifact as it passes through stages in the pipeline.
"""
function put_third_party_job_success_result(
clientToken, jobId; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PutThirdPartyJobSuccessResult",
Dict{String,Any}("clientToken" => clientToken, "jobId" => jobId);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_third_party_job_success_result(
clientToken,
jobId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"PutThirdPartyJobSuccessResult",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("clientToken" => clientToken, "jobId" => jobId),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
put_webhook(webhook)
put_webhook(webhook, params::Dict{String,<:Any})
Defines a webhook and returns a unique webhook URL generated by CodePipeline. This URL can
be supplied to third party source hosting providers to call every time there's a code
change. When CodePipeline receives a POST request on this URL, the pipeline defined in the
webhook is started as long as the POST request satisfied the authentication and filtering
requirements supplied when defining the webhook. RegisterWebhookWithThirdParty and
DeregisterWebhookWithThirdParty APIs can be used to automatically configure supported third
parties to call the generated webhook URL.
# Arguments
- `webhook`: The detail provided in an input file to create the webhook, such as the
webhook name, the pipeline name, and the action name. Give the webhook a unique name that
helps you identify it. You might name the webhook after the pipeline and action it targets
so that you can easily recognize what it's used for later.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`: The tags for the webhook.
"""
function put_webhook(webhook; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"PutWebhook",
Dict{String,Any}("webhook" => webhook);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function put_webhook(
webhook, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"PutWebhook",
Dict{String,Any}(mergewith(_merge, Dict{String,Any}("webhook" => webhook), params));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
register_webhook_with_third_party()
register_webhook_with_third_party(params::Dict{String,<:Any})
Configures a connection between the webhook that was created and the external tool with
events to be detected.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"webhookName"`: The name of an existing webhook created with PutWebhook to register with
a supported third party.
"""
function register_webhook_with_third_party(;
aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"RegisterWebhookWithThirdParty";
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function register_webhook_with_third_party(
params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"RegisterWebhookWithThirdParty",
params;
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
retry_stage_execution(pipeline_execution_id, pipeline_name, retry_mode, stage_name)
retry_stage_execution(pipeline_execution_id, pipeline_name, retry_mode, stage_name, params::Dict{String,<:Any})
You can retry a stage that has failed without having to run a pipeline again from the
beginning. You do this by either retrying the failed actions in a stage or by retrying all
actions in the stage starting from the first action in the stage. When you retry the failed
actions in a stage, all actions that are still in progress continue working, and failed
actions are triggered again. When you retry a failed stage from the first action in the
stage, the stage cannot have any actions in progress. Before a stage can be retried, it
must either have all actions failed or some actions failed and some succeeded.
# Arguments
- `pipeline_execution_id`: The ID of the pipeline execution in the failed stage to be
retried. Use the GetPipelineState action to retrieve the current pipelineExecutionId of the
failed stage
- `pipeline_name`: The name of the pipeline that contains the failed stage.
- `retry_mode`: The scope of the retry attempt.
- `stage_name`: The name of the failed stage to be retried.
"""
function retry_stage_execution(
pipelineExecutionId,
pipelineName,
retryMode,
stageName;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"RetryStageExecution",
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId,
"pipelineName" => pipelineName,
"retryMode" => retryMode,
"stageName" => stageName,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function retry_stage_execution(
pipelineExecutionId,
pipelineName,
retryMode,
stageName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"RetryStageExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId,
"pipelineName" => pipelineName,
"retryMode" => retryMode,
"stageName" => stageName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
rollback_stage(pipeline_name, stage_name, target_pipeline_execution_id)
rollback_stage(pipeline_name, stage_name, target_pipeline_execution_id, params::Dict{String,<:Any})
Rolls back a stage execution.
# Arguments
- `pipeline_name`: The name of the pipeline for which the stage will be rolled back.
- `stage_name`: The name of the stage in the pipeline to be rolled back.
- `target_pipeline_execution_id`: The pipeline execution ID for the stage to be rolled back
to.
"""
function rollback_stage(
pipelineName,
stageName,
targetPipelineExecutionId;
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"RollbackStage",
Dict{String,Any}(
"pipelineName" => pipelineName,
"stageName" => stageName,
"targetPipelineExecutionId" => targetPipelineExecutionId,
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function rollback_stage(
pipelineName,
stageName,
targetPipelineExecutionId,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"RollbackStage",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineName" => pipelineName,
"stageName" => stageName,
"targetPipelineExecutionId" => targetPipelineExecutionId,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
start_pipeline_execution(name)
start_pipeline_execution(name, params::Dict{String,<:Any})
Starts the specified pipeline. Specifically, it begins processing the latest commit to the
source location specified as part of the pipeline.
# Arguments
- `name`: The name of the pipeline to start.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"clientRequestToken"`: The system-generated unique ID used to identify a unique
execution request.
- `"sourceRevisions"`: A list that allows you to specify, or override, the source revision
for a pipeline execution that's being started. A source revision is the version with all
the changes to your application code, or source artifact, for the pipeline execution.
- `"variables"`: A list that overrides pipeline variables for a pipeline execution that's
being started. Variable names must match [A-Za-z0-9@-_]+, and the values can be anything
except an empty string.
"""
function start_pipeline_execution(name; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"StartPipelineExecution",
Dict{String,Any}("name" => name, "clientRequestToken" => string(uuid4()));
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function start_pipeline_execution(
name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"StartPipelineExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("name" => name, "clientRequestToken" => string(uuid4())),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
stop_pipeline_execution(pipeline_execution_id, pipeline_name)
stop_pipeline_execution(pipeline_execution_id, pipeline_name, params::Dict{String,<:Any})
Stops the specified pipeline execution. You choose to either stop the pipeline execution by
completing in-progress actions without starting subsequent actions, or by abandoning
in-progress actions. While completing or abandoning in-progress actions, the pipeline
execution is in a Stopping state. After all in-progress actions are completed or abandoned,
the pipeline execution is in a Stopped state.
# Arguments
- `pipeline_execution_id`: The ID of the pipeline execution to be stopped in the current
stage. Use the GetPipelineState action to retrieve the current pipelineExecutionId.
- `pipeline_name`: The name of the pipeline to stop.
# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"abandon"`: Use this option to stop the pipeline execution by abandoning, rather than
finishing, in-progress actions. This option can lead to failed or out-of-sequence tasks.
- `"reason"`: Use this option to enter comments, such as the reason the pipeline was
stopped.
"""
function stop_pipeline_execution(
pipelineExecutionId, pipelineName; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"StopPipelineExecution",
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId, "pipelineName" => pipelineName
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function stop_pipeline_execution(
pipelineExecutionId,
pipelineName,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"StopPipelineExecution",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}(
"pipelineExecutionId" => pipelineExecutionId,
"pipelineName" => pipelineName,
),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
tag_resource(resource_arn, tags)
tag_resource(resource_arn, tags, params::Dict{String,<:Any})
Adds to or modifies the tags of the given resource. Tags are metadata that can be used to
manage a resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource you want to add tags to.
- `tags`: The tags you want to modify or add to the resource.
"""
function tag_resource(resourceArn, tags; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"TagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function tag_resource(
resourceArn,
tags,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"TagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tags" => tags),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
untag_resource(resource_arn, tag_keys)
untag_resource(resource_arn, tag_keys, params::Dict{String,<:Any})
Removes tags from an Amazon Web Services resource.
# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the resource to remove tags from.
- `tag_keys`: The list of keys for the tags to be removed from the resource.
"""
function untag_resource(
resourceArn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
return codepipeline(
"UntagResource",
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function untag_resource(
resourceArn,
tagKeys,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"UntagResource",
Dict{String,Any}(
mergewith(
_merge,
Dict{String,Any}("resourceArn" => resourceArn, "tagKeys" => tagKeys),
params,
),
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_action_type(action_type)
update_action_type(action_type, params::Dict{String,<:Any})
Updates an action type that was created with any supported integration model, where the
action type is to be used by customers of the action type provider. Use a JSON file with
the action definition and UpdateActionType to provide the full structure.
# Arguments
- `action_type`: The action type definition for the action type to be updated.
"""
function update_action_type(actionType; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"UpdateActionType",
Dict{String,Any}("actionType" => actionType);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_action_type(
actionType,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"UpdateActionType",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("actionType" => actionType), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
"""
update_pipeline(pipeline)
update_pipeline(pipeline, params::Dict{String,<:Any})
Updates a specified pipeline with edits or changes to its structure. Use a JSON file with
the pipeline structure and UpdatePipeline to provide the full structure of the pipeline.
Updating the pipeline increases the version number of the pipeline by 1.
# Arguments
- `pipeline`: The name of the pipeline to be updated.
"""
function update_pipeline(pipeline; aws_config::AbstractAWSConfig=global_aws_config())
return codepipeline(
"UpdatePipeline",
Dict{String,Any}("pipeline" => pipeline);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
function update_pipeline(
pipeline,
params::AbstractDict{String};
aws_config::AbstractAWSConfig=global_aws_config(),
)
return codepipeline(
"UpdatePipeline",
Dict{String,Any}(
mergewith(_merge, Dict{String,Any}("pipeline" => pipeline), params)
);
aws_config=aws_config,
feature_set=SERVICE_FEATURE_SET,
)
end
| AWS | https://github.com/JuliaCloud/AWS.jl.git |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.