text:
"""
    create_quadratic_spline(x::Array{Date,1},y::Array{Float64,1} ; gradients::Union{missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    create_quadratic_spline(x::Array{Int,1},y::Array{Float64,1} ; gradients::Union{missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    create_quadratic_spline(x::Array{Float64,1},y::Array{Float64,1} ; gradients::Union{missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    create_quadratic_spline(schum::Schumaker; dim_name::Symbol = default_symbol)

Create a quadratic spline. The spline is a Schumaker shape-preserving spline which is taken from the SchumakerSpline.jl package.
"""
function create_quadratic_spline(x::Array{Date,1},y::Array{Float64,1} ; gradients::Union{Missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    x_as_Float64s = years_from_global_base.(x)
    return create_quadratic_spline(x_as_Float64s, y; gradients = gradients, extrapolation = extrapolation, left_gradient = left_gradient, right_gradient = right_gradient, dim_name = dim_name)
end

function create_quadratic_spline(x::Array{DatePeriod,1},y::Array{Float64,1} ; gradients::Union{Missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    x_as_Float64s = period_length.(x)
    return create_quadratic_spline(x_as_Float64s, y; gradients = gradients, extrapolation = extrapolation, left_gradient = left_gradient, right_gradient = right_gradient, dim_name = dim_name)
end

function create_quadratic_spline(x::Array{Int,1},y::Array{Float64,1} ; gradients::Union{Missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    x_as_Float64s = convert.(Float64, x)
    return create_quadratic_spline(x_as_Float64s, y; gradients = gradients, extrapolation = extrapolation, left_gradient = left_gradient, right_gradient = right_gradient, dim_name = dim_name)
end

function create_quadratic_spline(x::Array{Float64,1},y::Array{Float64,1} ; gradients::Union{Missing,Array{Float64,1}} = missing, extrapolation::Schumaker_ExtrapolationSchemes = Curve, left_gradient::Union{Missing,Float64} = missing, right_gradient::Union{Missing,Float64} = missing, dim_name::Symbol = default_symbol)
    schum = Schumaker(x, y; gradients = gradients, extrapolation = extrapolation, left_gradient = left_gradient, right_gradient = right_gradient)
    return create_quadratic_spline(schum; dim_name = dim_name)
end

function create_quadratic_spline(schum::Schumaker; dim_name::Symbol = default_symbol)
    starts_ = schum.IntStarts_
    coefficients = schum.coefficient_matrix_
    number_of_intervals = size(coefficients)[1]
    funcs_ = Array{Sum_Of_Functions,1}(undef, number_of_intervals)
    for i in 1:number_of_intervals
        quadratic = PE_Function(coefficients[i,1], Dict{Symbol,PE_Unit}(dim_name => PE_Unit(0.0, starts_[i], 2)))
        linear    = PE_Function(coefficients[i,2], Dict{Symbol,PE_Unit}(dim_name => PE_Unit(0.0, starts_[i], 1)))
        constant  = PE_Function(coefficients[i,3], Dict{Symbol,PE_Unit}(dim_name => PE_Unit(0.0, 0.0       , 0)))
        polynomial = Sum_Of_Functions([quadratic, linear, constant])
        funcs_[i] = polynomial
    end
    thresholds = OrderedDict{Symbol,Array{Float64,1}}(dim_name => starts_)
    return Piecewise_Function(funcs_, thresholds)
end

"""
    create_constant_interpolation_to_right(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_constant_interpolation_to_right(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_constant_interpolation_to_right(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)

Create a piecewise constant one-dimensional function which carries values from the left to the right.
"""
function create_constant_interpolation_to_right(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_Float = years_from_global_base.(x)
    return create_constant_interpolation_to_right(x_Float,y; dim_name = dim_name)
end

function create_constant_interpolation_to_right(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_as_Float64s = period_length.(x)
    return create_constant_interpolation_to_right(x_as_Float64s, y; dim_name = dim_name)
end

function create_constant_interpolation_to_right(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_ = vcat(-Inf,x)
    y = vcat(y[1], y)
    funcs_ = PE_Function.(y)
    thresholds_ = OrderedDict{Symbol,Array{Float64,1}}(dim_name => x_)
    return Piecewise_Function(funcs_, thresholds_)
end

"""
    create_constant_interpolation_to_left(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_constant_interpolation_to_left(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_constant_interpolation_to_left(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)

Create a piecewise constant one-dimensional function which carries values from the right to the left.
"""
function create_constant_interpolation_to_left(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_Float = years_from_global_base.(x)
    return create_constant_interpolation_to_left(x_Float , y ; dim_name = dim_name)
end

function create_constant_interpolation_to_left(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_as_Float64s = period_length.(x)
    return create_constant_interpolation_to_left(x_as_Float64s, y; dim_name = dim_name)
end

function create_constant_interpolation_to_left(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_ = vcat(-Inf,x[1:(length(x)-1)])
    funcs_ = PE_Function.(y)
    thresholds_ = OrderedDict{Symbol,Array{Float64,1}}(dim_name => x_)
    return Piecewise_Function(funcs_, thresholds_)
end

"""
    create_linear_interpolation(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_linear_interpolation(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    create_linear_interpolation(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)

Create a piecewise linear one-dimensional function which interpolates linearly between datapoints.
"""
function create_linear_interpolation(x::Array{Date,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_Float = years_from_global_base.(x)
    return create_linear_interpolation(x_Float,y; dim_name = dim_name)
end

function create_linear_interpolation(x::Array{DatePeriod,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    x_as_Float64s = period_length.(x)
    return create_linear_interpolation(x_as_Float64s, y; dim_name = dim_name)
end

function create_linear_interpolation(x::Array{Float64,1},y::Array{Float64,1}; dim_name::Symbol = default_symbol)
    len = length(x)
    if len < 2
        error("Insufficient data to linearly interpolate")
    end
    starts_ = Array{Float64}(undef, len-1)
    funcs_  = Array{Sum_Of_Functions}(undef, len-1)
    coefficient = (y[2] - y[1])/(x[2] - x[1])
    starts_[1] = -Inf
    con = PE_Function(y[1])
    lin = PE_Function(coefficient,Dict{Symbol,PE_Unit}(dim_name => PE_Unit(0.0, x[1], 1)))
    funcs_[1]  = con + lin
    if len > 2
        for i in 2:(len-1)
            starts_[i] = x[i]
            coefficient = (y[i+1] - y[i])/(x[i+1] - x[i])
            con = PE_Function(y[i])
            lin = PE_Function(coefficient,Dict{Symbol,PE_Unit}(dim_name => PE_Unit(0.0, x[i], 1)))
            funcs_[i]  = con + lin
        end
    end
    thresholds_ = OrderedDict{Symbol,Array{Float64,1}}(dim_name => starts_)
    return Piecewise_Function(funcs_, thresholds_)
end


text:
using Turing, Random, Test

dir = splitdir(splitdir(pathof(Turing))[1])[1]
include(dir*"/test/test_utils/AllUtils.jl")

@testset "smc.jl" begin
    # No tests.
end

@testset "pmmh.jl" begin
    @turing_testset "pmmh constructor" begin
        N = 2000
        s1 = PMMH(N, SMC(10, :s), MH(1,(:m, s -> Normal(s, sqrt(1)))))
        s2 = PMMH(N, SMC(10, :s), MH(1, :m))
        s3 = PIMH(N, SMC(10))

        c1 = sample(gdemo_default, s1)
        c2 = sample(gdemo_default, s2)
        c3 = sample(gdemo_default, s3)
    end
    @numerical_testset "pmmh inference" begin
        alg = PMMH(2000, SMC(20, :m), MH(1, (:s, GKernel(1))))
        chain = sample(gdemo_default, alg)
        check_gdemo(chain, eps=0.1)

        # PMMH with prior as proposal
        alg = PMMH(2000, SMC(20, :m), MH(1, :s))
        chain = sample(gdemo_default, alg)
        check_gdemo(chain, eps=0.1)

        # PIMH
        alg = PIMH(2000, SMC(20))
        chain = sample(gdemo_default, alg)
        check_gdemo(chain)

        # MoGtest
        pmmh = PMMH(2000,
            SMC(10, :z1, :z2, :z3, :z4),
            MH(1, :mu1, :mu2))
        chain = sample(MoGtest_default, pmmh)

        check_MoGtest_default(chain, eps = 0.1)
    end
end

@testset "ipmcmc.jl" begin
    @turing_testset "ipmcmc constructor" begin
        Random.seed!(125)

        N = 50
        s1 = IPMCMC(10, N, 4, 2)
        s2 = IPMCMC(10, N, 4)

        c1 = sample(gdemo_default, s1)
        c2 = sample(gdemo_default, s2)
    end
    @numerical_testset "ipmcmc inference" begin
        alg = IPMCMC(30, 500, 4)
        chain = sample(gdemo_default, alg)
        check_gdemo(chain)

        alg2 = IPMCMC(15, 100, 10)
        chain2 = sample(MoGtest_default, alg2)
        check_MoGtest_default(chain2, eps=0.2)
    end
end

@turing_testset "resample.jl" begin
    D = [0.3, 0.4, 0.3]
    num_samples = Int(1e6)
    resSystematic = Turing.Inference.resample_systematic(D, num_samples )
    resStratified = Turing.Inference.resample_stratified(D, num_samples )
    resMultinomial= Turing.Inference.resample_multinomial(D, num_samples )
    resResidual   = Turing.Inference.resample_residual(D, num_samples )
    Turing.Inference.resample(D)
    resSystematic2=Turing.Inference.resample(D, num_samples )

    @test sum(resSystematic .== 2) ≈ (num_samples * 0.4) atol=1e-3*num_samples
    @test sum(resSystematic2 .== 2) ≈ (num_samples * 0.4) atol=1e-3*num_samples
    @test sum(resStratified .== 2) ≈ (num_samples * 0.4) atol=1e-3*num_samples
    @test sum(resMultinomial .== 2) ≈ (num_samples * 0.4) atol=1e-2*num_samples
    @test sum(resResidual .== 2) ≈ (num_samples * 0.4) atol=1e-2*num_samples
end

ext: jl


text:
abstract type AbstractParam <: AbstractDelayed end

"""
$(TYPEDSIGNATURES)

A node of the space used to assign parameter labels. Only Param objects are extracted into
the vals dictionary for output. Therefore, every parameter of the user's function must have
a corresponding Param object in the space.
"""
struct Param <: AbstractParam
    label::Symbol
    obj::AbstractDelayed
end


text:
# This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: s3_control
using AWS.Compat
using AWS.UUIDs

"""
    create_access_point(bucket, name, x-amz-account-id)
    create_access_point(bucket, name, x-amz-account-id, params::Dict{String,<:Any})

Creates an access point and associates it with the specified bucket. For more information,
see Managing Data Access with Amazon S3 Access Points in the Amazon Simple Storage Service
User Guide.   Using this action with Amazon S3 on Outposts  This action:    Requires a
virtual private cloud (VPC) configuration as S3 on Outposts only supports VPC style access
points.   Does not support ACL on S3 on Outposts buckets.   Does not support Public Access
on S3 on Outposts buckets.   Does not support object lock for S3 on Outposts buckets.   For
more information, see Using Amazon S3 on Outposts in the Amazon Simple Storage Service User
Guide . All Amazon S3 on Outposts REST API requests for this action require an additional
parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint
hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3
on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section.  The following actions are
related to CreateAccessPoint:    GetAccessPoint     DeleteAccessPoint     ListAccessPoints

# Arguments
- `bucket`: The name of the bucket that you want to associate this access point with. For
  using this parameter with Amazon S3 on Outposts with the REST API, you must specify the
  name and the x-amz-outpost-id as well. For using this parameter with S3 on Outposts with
  the AWS SDK and CLI, you must specify the ARN of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `name`: The name you want to assign to this access point.
- `x-amz-account-id`: The AWS account ID for the owner of the bucket for which you want to
  create an access point.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PublicAccessBlockConfiguration"`:
- `"VpcConfiguration"`: If you include this field, Amazon S3 restricts access to this
  access point to requests from the specified virtual private cloud (VPC).  This is required
  for creating an access point for Amazon S3 on Outposts buckets.
"""
create_access_point(Bucket, name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/accesspoint/$(name)", Dict{String, Any}("Bucket"=>Bucket, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
create_access_point(Bucket, name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/accesspoint/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Bucket"=>Bucket, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    create_bucket(name)
    create_bucket(name, params::Dict{String,<:Any})

 This action creates an Amazon S3 on Outposts bucket. To create an S3 bucket, see Create
Bucket in the Amazon Simple Storage Service API.   Creates a new Outposts bucket. By
creating the bucket, you become the bucket owner. To create an Outposts bucket, you must
have S3 on Outposts. For more information, see Using Amazon S3 on Outposts in Amazon Simple
Storage Service User Guide. Not every string is an acceptable bucket name. For information
on bucket naming restrictions, see Working with Amazon S3 Buckets. S3 on Outposts buckets
support:   Tags   LifecycleConfigurations for deleting expired objects   For a list of
Amazon S3 features not supported by Amazon S3 on Outposts, see Unsupported Amazon S3
features. For an example of the request syntax for Amazon S3 on Outposts that uses the S3
on Outposts endpoint hostname prefix and x-amz-outpost-id in your API request, see the
Examples section. The following actions are related to CreateBucket for Amazon S3 on
Outposts:    PutObject     GetBucket     DeleteBucket     CreateAccessPoint
PutAccessPointPolicy

# Arguments
- `name`: The name of the bucket.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CreateBucketConfiguration"`: The configuration information for the bucket.  This is not
  supported by Amazon S3 on Outposts buckets.
- `"x-amz-acl"`: The canned ACL to apply to the bucket.  This is not supported by Amazon S3
  on Outposts buckets.
- `"x-amz-bucket-object-lock-enabled"`: Specifies whether you want S3 Object Lock to be
  enabled for the new bucket.  This is not supported by Amazon S3 on Outposts buckets.
- `"x-amz-grant-full-control"`: Allows grantee the read, write, read ACP, and write ACP
  permissions on the bucket.  This is not supported by Amazon S3 on Outposts buckets.
- `"x-amz-grant-read"`: Allows grantee to list the objects in the bucket.  This is not
  supported by Amazon S3 on Outposts buckets.
- `"x-amz-grant-read-acp"`: Allows grantee to read the bucket ACL.  This is not supported
  by Amazon S3 on Outposts buckets.
- `"x-amz-grant-write"`: Allows grantee to create, overwrite, and delete any object in the
  bucket.  This is not supported by Amazon S3 on Outposts buckets.
- `"x-amz-grant-write-acp"`: Allows grantee to write the ACL for the applicable bucket.
  This is not supported by Amazon S3 on Outposts buckets.
- `"x-amz-outpost-id"`: The ID of the Outposts where the bucket is being created.  This is
  required by Amazon S3 on Outposts buckets.
"""
create_bucket(name; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)"; aws_config=aws_config)
create_bucket(name, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)", params; aws_config=aws_config)

"""
    create_job(client_request_token, manifest, operation, priority, report, role_arn, x-amz-account-id)
    create_job(client_request_token, manifest, operation, priority, report, role_arn, x-amz-account-id, params::Dict{String,<:Any})

You can use S3 Batch Operations to perform large-scale batch actions on Amazon S3 objects.
Batch Operations can run a single action on lists of Amazon S3 objects that you specify.
For more information, see S3 Batch Operations in the Amazon Simple Storage Service User
Guide. This action creates a S3 Batch Operations job.  Related actions include:
DescribeJob     ListJobs     UpdateJobPriority     UpdateJobStatus     JobOperation

# Arguments
- `client_request_token`: An idempotency token to ensure that you don't accidentally submit
  the same request twice. You can use any string up to the maximum length.
- `manifest`: Configuration parameters for the manifest.
- `operation`: The action that you want this job to perform on every object listed in the
  manifest. For more information about the available actions, see Operations in the Amazon
  Simple Storage Service User Guide.
- `priority`: The numerical priority for this job. Higher numbers indicate higher priority.
- `report`: Configuration parameters for the optional job-completion report.
- `role_arn`: The Amazon Resource Name (ARN) for the AWS Identity and Access Management
  (IAM) role that Batch Operations will use to run this job's action on every object in the
  manifest.
- `x-amz-account-id`: The AWS account ID that creates the job.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ConfirmationRequired"`: Indicates whether confirmation is required before Amazon S3
  runs the job. Confirmation is only required for jobs created through the Amazon S3 console.
- `"Description"`: A description for this job. You can use any string within the permitted
  length. Descriptions don't need to be unique and can be used for multiple jobs.
- `"Tags"`: A set of tags to associate with the S3 Batch Operations job. This is an
  optional parameter.
"""
create_job(ClientRequestToken, Manifest, Operation, Priority, Report, RoleArn, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs", Dict{String, Any}("ClientRequestToken"=>ClientRequestToken, "Manifest"=>Manifest, "Operation"=>Operation, "Priority"=>Priority, "Report"=>Report, "RoleArn"=>RoleArn, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
create_job(ClientRequestToken, Manifest, Operation, Priority, Report, RoleArn, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ClientRequestToken"=>ClientRequestToken, "Manifest"=>Manifest, "Operation"=>Operation, "Priority"=>Priority, "Report"=>Report, "RoleArn"=>RoleArn, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_access_point(name, x-amz-account-id)
    delete_access_point(name, x-amz-account-id, params::Dict{String,<:Any})

Deletes the specified access point. All Amazon S3 on Outposts REST API requests for this
action require an additional parameter of x-amz-outpost-id to be passed with the request
and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the
request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname
prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples
section. The following actions are related to DeleteAccessPoint:    CreateAccessPoint
GetAccessPoint     ListAccessPoints

# Arguments
- `name`: The name of the access point you want to delete. For using this parameter with
  Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id
  as well. For using this parameter with S3 on Outposts with the AWS SDK and CLI, you must
  specify the ARN of the access point accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint
  /<my-accesspoint-name>. For example, to access the access point reports-ap through
  outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding
  of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap.
  The value must be URL encoded.
- `x-amz-account-id`: The account ID for the account that owns the specified access point.

"""
delete_access_point(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/accesspoint/$(name)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_access_point(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/accesspoint/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_access_point_policy(name, x-amz-account-id)
    delete_access_point_policy(name, x-amz-account-id, params::Dict{String,<:Any})

Deletes the access point policy for the specified access point.  All Amazon S3 on Outposts
REST API requests for this action require an additional parameter of x-amz-outpost-id to be
passed with the request and an S3 on Outposts endpoint hostname prefix instead of
s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3
on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access
point ARN, see the Examples section. The following actions are related to
DeleteAccessPointPolicy:    PutAccessPointPolicy     GetAccessPointPolicy

# Arguments
- `name`: The name of the access point whose policy you want to delete. For using this
  parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the
  x-amz-outpost-id as well. For using this parameter with S3 on Outposts with the AWS SDK and
  CLI, you must specify the ARN of the access point accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint
  /<my-accesspoint-name>. For example, to access the access point reports-ap through
  outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding
  of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap.
  The value must be URL encoded.
- `x-amz-account-id`: The account ID for the account that owns the specified access point.

"""
delete_access_point_policy(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_access_point_policy(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_bucket(name, x-amz-account-id)
    delete_bucket(name, x-amz-account-id, params::Dict{String,<:Any})

 This action deletes an Amazon S3 on Outposts bucket. To delete an S3 bucket, see
DeleteBucket in the Amazon Simple Storage Service API.   Deletes the Amazon S3 on Outposts
bucket. All objects (including all object versions and delete markers) in the bucket must
be deleted before the bucket itself can be deleted. For more information, see Using Amazon
S3 on Outposts in Amazon Simple Storage Service User Guide. All Amazon S3 on Outposts REST
API requests for this action require an additional parameter of x-amz-outpost-id to be
passed with the request and an S3 on Outposts endpoint hostname prefix instead of
s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3
on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access
point ARN, see the Examples section.  Related Resources     CreateBucket     GetBucket
DeleteObject

# Arguments
- `name`: Specifies the bucket being deleted. For using this parameter with Amazon S3 on
  Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well. For
  using this parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN
  of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The account ID that owns the Outposts bucket.

"""
delete_bucket(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_bucket(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_bucket_lifecycle_configuration(name, x-amz-account-id)
    delete_bucket_lifecycle_configuration(name, x-amz-account-id, params::Dict{String,<:Any})

 This action deletes an Amazon S3 on Outposts bucket's lifecycle configuration. To delete
an S3 bucket's lifecycle configuration, see DeleteBucketLifecycle in the Amazon Simple
Storage Service API.   Deletes the lifecycle configuration from the specified Outposts
bucket. Amazon S3 on Outposts removes all the lifecycle configuration rules in the
lifecycle subresource associated with the bucket. Your objects never expire, and Amazon S3
on Outposts no longer automatically deletes any objects on the basis of rules contained in
the deleted lifecycle configuration. For more information, see Using Amazon S3 on Outposts
in Amazon Simple Storage Service User Guide. To use this action, you must have permission
to perform the s3-outposts:DeleteLifecycleConfiguration action. By default, the bucket
owner has this permission and the Outposts bucket owner can grant this permission to
others. All Amazon S3 on Outposts REST API requests for this action require an additional
parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint
hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3
on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. For more information about
object expiration, see Elements to Describe Lifecycle Actions. Related actions include:
PutBucketLifecycleConfiguration     GetBucketLifecycleConfiguration

# Arguments
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The account ID of the lifecycle configuration to delete.

"""
delete_bucket_lifecycle_configuration(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_bucket_lifecycle_configuration(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_bucket_policy(name, x-amz-account-id)
    delete_bucket_policy(name, x-amz-account-id, params::Dict{String,<:Any})

 This action deletes an Amazon S3 on Outposts bucket policy. To delete an S3 bucket policy,
see DeleteBucketPolicy in the Amazon Simple Storage Service API.   This implementation of
the DELETE action uses the policy subresource to delete the policy of a specified Amazon S3
on Outposts bucket. If you are using an identity other than the root user of the AWS
account that owns the bucket, the calling identity must have the
s3-outposts:DeleteBucketPolicy permissions on the specified Outposts bucket and belong to
the bucket owner's account to use this action. For more information, see Using Amazon S3 on
Outposts in Amazon Simple Storage Service User Guide. If you don't have DeleteBucketPolicy
permissions, Amazon S3 returns a 403 Access Denied error. If you have the correct
permissions, but you're not using an identity that belongs to the bucket owner's account,
Amazon S3 returns a 405 Method Not Allowed error.   As a security precaution, the root user
of the AWS account that owns a bucket can always use this action, even if the policy
explicitly denies the root user the ability to perform this action.  For more information
about bucket policies, see Using Bucket Policies and User Policies.  All Amazon S3 on
Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to DeleteBucketPolicy:    GetBucketPolicy     PutBucketPolicy

# Arguments
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The account ID of the Outposts bucket.

"""
delete_bucket_policy(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/policy", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_bucket_policy(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_bucket_tagging(name, x-amz-account-id)
    delete_bucket_tagging(name, x-amz-account-id, params::Dict{String,<:Any})

 This action deletes an Amazon S3 on Outposts bucket's tags. To delete an S3 bucket tags,
see DeleteBucketTagging in the Amazon Simple Storage Service API.   Deletes the tags from
the Outposts bucket. For more information, see Using Amazon S3 on Outposts in Amazon Simple
Storage Service User Guide. To use this action, you must have permission to perform the
PutBucketTagging action. By default, the bucket owner has this permission and can grant
this permission to others.  All Amazon S3 on Outposts REST API requests for this action
require an additional parameter of x-amz-outpost-id to be passed with the request and an S3
on Outposts endpoint hostname prefix instead of s3-control. For an example of the request
syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and
the x-amz-outpost-id derived using the access point ARN, see the Examples section. The
following actions are related to DeleteBucketTagging:    GetBucketTagging
PutBucketTagging

# Arguments
- `name`: The bucket ARN that has the tag set to be removed. For using this parameter with
  Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id
  as well. For using this parameter with S3 on Outposts with the AWS SDK and CLI, you must
  specify the ARN of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket tag set to be removed.

"""
delete_bucket_tagging(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_bucket_tagging(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_job_tagging(id, x-amz-account-id)
    delete_job_tagging(id, x-amz-account-id, params::Dict{String,<:Any})

Removes the entire tag set from the specified S3 Batch Operations job. To use this
operation, you must have permission to perform the s3:DeleteJobTagging action. For more
information, see Controlling access and labeling jobs using tags in the Amazon Simple
Storage Service User Guide.  Related actions include:    CreateJob     GetJobTagging
PutJobTagging

# Arguments
- `id`: The ID for the S3 Batch Operations job whose tags you want to delete.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

"""
delete_job_tagging(id, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_job_tagging(id, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_public_access_block(x-amz-account-id)
    delete_public_access_block(x-amz-account-id, params::Dict{String,<:Any})

Removes the PublicAccessBlock configuration for an AWS account. For more information, see
Using Amazon S3 block public access. Related actions include:    GetPublicAccessBlock
PutPublicAccessBlock

# Arguments
- `x-amz-account-id`: The account ID for the AWS account whose PublicAccessBlock
  configuration you want to remove.

"""
delete_public_access_block(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_public_access_block(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_storage_lens_configuration(storagelensid, x-amz-account-id)
    delete_storage_lens_configuration(storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Deletes the Amazon S3 Storage Lens configuration. For more information about S3 Storage
Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens  in the
Amazon Simple Storage Service User Guide.  To use this action, you must have permission to
perform the s3:DeleteStorageLensConfiguration action. For more information, see Setting
permissions to use Amazon S3 Storage Lens in the Amazon Simple Storage Service User Guide.

# Arguments
- `storagelensid`: The ID of the S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

"""
delete_storage_lens_configuration(storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_storage_lens_configuration(storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    delete_storage_lens_configuration_tagging(storagelensid, x-amz-account-id)
    delete_storage_lens_configuration_tagging(storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Deletes the Amazon S3 Storage Lens configuration tags. For more information about S3
Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens  in
the Amazon Simple Storage Service User Guide.  To use this action, you must have permission
to perform the s3:DeleteStorageLensConfigurationTagging action. For more information, see
Setting permissions to use Amazon S3 Storage Lens in the Amazon Simple Storage Service User
Guide.

# Arguments
- `storagelensid`: The ID of the S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

"""
delete_storage_lens_configuration_tagging(storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
delete_storage_lens_configuration_tagging(storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("DELETE", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    describe_job(id, x-amz-account-id)
    describe_job(id, x-amz-account-id, params::Dict{String,<:Any})

Retrieves the configuration parameters and status for a Batch Operations job. For more
information, see S3 Batch Operations in the Amazon Simple Storage Service User Guide.
Related actions include:    CreateJob     ListJobs     UpdateJobPriority
UpdateJobStatus

# Arguments
- `id`: The ID for the job whose information you want to retrieve.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

"""
describe_job(id, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs/$(id)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
describe_job(id, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs/$(id)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_access_point(name, x-amz-account-id)
    get_access_point(name, x-amz-account-id, params::Dict{String,<:Any})

Returns configuration information about the specified access point.  All Amazon S3 on
Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to GetAccessPoint:    CreateAccessPoint     DeleteAccessPoint     ListAccessPoints

# Arguments
- `name`: The name of the access point whose configuration information you want to
  retrieve. For using this parameter with Amazon S3 on Outposts with the REST API, you must
  specify the name and the x-amz-outpost-id as well. For using this parameter with S3 on
  Outposts with the AWS SDK and CLI, you must specify the ARN of the access point accessed in
  the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint
  /<my-accesspoint-name>. For example, to access the access point reports-ap through
  outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding
  of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap.
  The value must be URL encoded.
- `x-amz-account-id`: The account ID for the account that owns the specified access point.

"""
get_access_point(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_access_point(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_access_point_policy(name, x-amz-account-id)
    get_access_point_policy(name, x-amz-account-id, params::Dict{String,<:Any})

Returns the access point policy associated with the specified access point. The following
actions are related to GetAccessPointPolicy:    PutAccessPointPolicy
DeleteAccessPointPolicy

# Arguments
- `name`: The name of the access point whose policy you want to retrieve. For using this
  parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the
  x-amz-outpost-id as well. For using this parameter with S3 on Outposts with the AWS SDK and
  CLI, you must specify the ARN of the access point accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint
  /<my-accesspoint-name>. For example, to access the access point reports-ap through
  outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding
  of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap.
  The value must be URL encoded.
- `x-amz-account-id`: The account ID for the account that owns the specified access point.

"""
get_access_point_policy(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_access_point_policy(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_access_point_policy_status(name, x-amz-account-id)
    get_access_point_policy_status(name, x-amz-account-id, params::Dict{String,<:Any})

Indicates whether the specified access point currently has a policy that allows public
access. For more information about public access through access points, see Managing Data
Access with Amazon S3 Access Points in the Amazon Simple Storage Service Developer Guide.

# Arguments
- `name`: The name of the access point whose policy status you want to retrieve.
- `x-amz-account-id`: The account ID for the account that owns the specified access point.

"""
get_access_point_policy_status(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)/policyStatus", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_access_point_policy_status(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint/$(name)/policyStatus", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_bucket(name, x-amz-account-id)
    get_bucket(name, x-amz-account-id, params::Dict{String,<:Any})

Gets an Amazon S3 on Outposts bucket. For more information, see  Using Amazon S3 on
Outposts in the Amazon Simple Storage Service User Guide. If you are using an identity
other than the root user of the AWS account that owns the bucket, the calling identity must
have the s3-outposts:GetBucket permissions on the specified bucket and belong to the bucket
owner's account in order to use this action. Only users from Outposts bucket owner account
with the right permissions can perform actions on an Outposts bucket.   If you don't have
s3-outposts:GetBucket permissions or you're not using an identity that belongs to the
bucket owner's account, Amazon S3 returns a 403 Access Denied error. The following actions
are related to GetBucket for Amazon S3 on Outposts: All Amazon S3 on Outposts REST API
requests for this action require an additional parameter of x-amz-outpost-id to be passed
with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For
an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts
endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see
the Examples section.    PutObject     CreateBucket     DeleteBucket

# Arguments
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

"""
get_bucket(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_bucket(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_bucket_lifecycle_configuration(name, x-amz-account-id)
    get_bucket_lifecycle_configuration(name, x-amz-account-id, params::Dict{String,<:Any})

 This action gets an Amazon S3 on Outposts bucket's lifecycle configuration. To get an S3
bucket's lifecycle configuration, see GetBucketLifecycleConfiguration in the Amazon Simple
Storage Service API.   Returns the lifecycle configuration information set on the Outposts
bucket. For more information, see Using Amazon S3 on Outposts and for information about
lifecycle configuration, see  Object Lifecycle Management in Amazon Simple Storage Service
User Guide. To use this action, you must have permission to perform the
s3-outposts:GetLifecycleConfiguration action. The Outposts bucket owner has this
permission, by default. The bucket owner can grant this permission to others. For more
information about permissions, see Permissions Related to Bucket Subresource Operations and
Managing Access Permissions to Your Amazon S3 Resources. All Amazon S3 on Outposts REST API
requests for this action require an additional parameter of x-amz-outpost-id to be passed
with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For
an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts
endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see
the Examples section.  GetBucketLifecycleConfiguration has the following special error:
Error code: NoSuchLifecycleConfiguration    Description: The lifecycle configuration does
not exist.   HTTP Status Code: 404 Not Found   SOAP Fault Code Prefix: Client     The
following actions are related to GetBucketLifecycleConfiguration:
PutBucketLifecycleConfiguration     DeleteBucketLifecycleConfiguration

# Arguments
- `name`: The Amazon Resource Name (ARN) of the bucket. For using this parameter with
  Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id
  as well. For using this parameter with S3 on Outposts with the AWS SDK and CLI, you must
  specify the ARN of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

"""
get_bucket_lifecycle_configuration(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_bucket_lifecycle_configuration(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_bucket_policy(name, x-amz-account-id)
    get_bucket_policy(name, x-amz-account-id, params::Dict{String,<:Any})

 This action gets a bucket policy for an Amazon S3 on Outposts bucket. To get a policy for
an S3 bucket, see GetBucketPolicy in the Amazon Simple Storage Service API.   Returns the
policy of a specified Outposts bucket. For more information, see Using Amazon S3 on
Outposts in the Amazon Simple Storage Service User Guide. If you are using an identity
other than the root user of the AWS account that owns the bucket, the calling identity must
have the GetBucketPolicy permissions on the specified bucket and belong to the bucket
owner's account in order to use this action. Only users from Outposts bucket owner account
with the right permissions can perform actions on an Outposts bucket. If you don't have
s3-outposts:GetBucketPolicy permissions or you're not using an identity that belongs to the
bucket owner's account, Amazon S3 returns a 403 Access Denied error.  As a security
precaution, the root user of the AWS account that owns a bucket can always use this action,
even if the policy explicitly denies the root user the ability to perform this action.  For
more information about bucket policies, see Using Bucket Policies and User Policies. All
Amazon S3 on Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to GetBucketPolicy:    GetObject     PutBucketPolicy     DeleteBucketPolicy

# Arguments
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

"""
get_bucket_policy(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/policy", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_bucket_policy(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_bucket_tagging(name, x-amz-account-id)
    get_bucket_tagging(name, x-amz-account-id, params::Dict{String,<:Any})

 This action gets an Amazon S3 on Outposts bucket's tags. To get an S3 bucket tags, see
GetBucketTagging in the Amazon Simple Storage Service API.   Returns the tag set associated
with the Outposts bucket. For more information, see Using Amazon S3 on Outposts in the
Amazon Simple Storage Service User Guide. To use this action, you must have permission to
perform the GetBucketTagging action. By default, the bucket owner has this permission and
can grant this permission to others.  GetBucketTagging has the following special error:
Error code: NoSuchTagSetError    Description: There is no tag set associated with the
bucket.     All Amazon S3 on Outposts REST API requests for this action require an
additional parameter of x-amz-outpost-id to be passed with the request and an S3 on
Outposts endpoint hostname prefix instead of s3-control. For an example of the request
syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and
the x-amz-outpost-id derived using the access point ARN, see the Examples section. The
following actions are related to GetBucketTagging:    PutBucketTagging
DeleteBucketTagging

# Arguments
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

"""
get_bucket_tagging(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_bucket_tagging(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_job_tagging(id, x-amz-account-id)
    get_job_tagging(id, x-amz-account-id, params::Dict{String,<:Any})

Returns the tags on an S3 Batch Operations job. To use this operation, you must have
permission to perform the s3:GetJobTagging action. For more information, see Controlling
access and labeling jobs using tags in the Amazon Simple Storage Service User Guide.
Related actions include:    CreateJob     PutJobTagging     DeleteJobTagging

# Arguments
- `id`: The ID for the S3 Batch Operations job whose tags you want to retrieve.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

"""
get_job_tagging(id, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_job_tagging(id, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_public_access_block(x-amz-account-id)
    get_public_access_block(x-amz-account-id, params::Dict{String,<:Any})

Retrieves the PublicAccessBlock configuration for an AWS account. For more information, see
 Using Amazon S3 block public access. Related actions include:    DeletePublicAccessBlock
  PutPublicAccessBlock

# Arguments
- `x-amz-account-id`: The account ID for the AWS account whose PublicAccessBlock
  configuration you want to retrieve.

"""
get_public_access_block(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_public_access_block(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_storage_lens_configuration(storagelensid, x-amz-account-id)
    get_storage_lens_configuration(storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Gets the Amazon S3 Storage Lens configuration. For more information, see Assessing your
storage activity and usage with Amazon S3 Storage Lens  in the Amazon Simple Storage
Service User Guide.  To use this action, you must have permission to perform the
s3:GetStorageLensConfiguration action. For more information, see Setting permissions to use
Amazon S3 Storage Lens in the Amazon Simple Storage Service User Guide.

# Arguments
- `storagelensid`: The ID of the Amazon S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

"""
get_storage_lens_configuration(storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_storage_lens_configuration(storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    get_storage_lens_configuration_tagging(storagelensid, x-amz-account-id)
    get_storage_lens_configuration_tagging(storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Gets the tags of Amazon S3 Storage Lens configuration. For more information about S3
Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens  in
the Amazon Simple Storage Service User Guide.  To use this action, you must have permission
to perform the s3:GetStorageLensConfigurationTagging action. For more information, see
Setting permissions to use Amazon S3 Storage Lens in the Amazon Simple Storage Service User
Guide.

# Arguments
- `storagelensid`: The ID of the Amazon S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

"""
get_storage_lens_configuration_tagging(storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
get_storage_lens_configuration_tagging(storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    list_access_points(x-amz-account-id)
    list_access_points(x-amz-account-id, params::Dict{String,<:Any})

Returns a list of the access points currently associated with the specified bucket. You can
retrieve up to 1000 access points per call. If the specified bucket has more than 1,000
access points (or the number specified in maxResults, whichever is less), the response will
include a continuation token that you can use to list the additional access points.  All
Amazon S3 on Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to ListAccessPoints:    CreateAccessPoint     DeleteAccessPoint     GetAccessPoint

# Arguments
- `x-amz-account-id`: The AWS account ID for owner of the bucket whose access points you
  want to list.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"bucket"`: The name of the bucket whose associated access points you want to list. For
  using this parameter with Amazon S3 on Outposts with the REST API, you must specify the
  name and the x-amz-outpost-id as well. For using this parameter with S3 on Outposts with
  the AWS SDK and CLI, you must specify the ARN of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `"maxResults"`: The maximum number of access points that you want to include in the list.
  If the specified bucket has more than this number of access points, then the response will
  include a continuation token in the NextToken field that you can use to retrieve the next
  page of access points.
- `"nextToken"`: A continuation token. If a previous call to ListAccessPoints returned a
  continuation token in the NextToken field, then providing that value here causes Amazon S3
  to retrieve the next page of results.
"""
list_access_points(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
list_access_points(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/accesspoint", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    list_jobs(x-amz-account-id)
    list_jobs(x-amz-account-id, params::Dict{String,<:Any})

Lists current S3 Batch Operations jobs and jobs that have ended within the last 30 days for
the AWS account making the request. For more information, see S3 Batch Operations in the
Amazon Simple Storage Service User Guide. Related actions include:     CreateJob
DescribeJob     UpdateJobPriority     UpdateJobStatus

# Arguments
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"jobStatuses"`: The List Jobs request returns jobs that match the statuses listed in
  this element.
- `"maxResults"`: The maximum number of jobs that Amazon S3 will include in the List Jobs
  response. If there are more jobs than this number, the response will include a pagination
  token in the NextToken field to enable you to retrieve the next page of results.
- `"nextToken"`: A pagination token to request the next page of results. Use the token that
  Amazon S3 returned in the NextToken element of the ListJobsResult from the previous List
  Jobs request.
"""
list_jobs(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
list_jobs(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/jobs", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    list_regional_buckets(x-amz-account-id)
    list_regional_buckets(x-amz-account-id, params::Dict{String,<:Any})

Returns a list of all Outposts buckets in an Outpost that are owned by the authenticated
sender of the request. For more information, see Using Amazon S3 on Outposts in the Amazon
Simple Storage Service User Guide. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and x-amz-outpost-id in your
request, see the Examples section.

# Arguments
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`:
- `"nextToken"`:
- `"x-amz-outpost-id"`: The ID of the AWS Outposts.  This is required by Amazon S3 on
  Outposts buckets.
"""
list_regional_buckets(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
list_regional_buckets(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/bucket", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    list_storage_lens_configurations(x-amz-account-id)
    list_storage_lens_configurations(x-amz-account-id, params::Dict{String,<:Any})

Gets a list of Amazon S3 Storage Lens configurations. For more information about S3 Storage
Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens  in the
Amazon Simple Storage Service User Guide.  To use this action, you must have permission to
perform the s3:ListStorageLensConfigurations action. For more information, see Setting
permissions to use Amazon S3 Storage Lens in the Amazon Simple Storage Service User Guide.

# Arguments
- `x-amz-account-id`: The account ID of the requester.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"nextToken"`: A pagination token to request the next page of results.
"""
list_storage_lens_configurations(x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
list_storage_lens_configurations(x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("GET", "/v20180820/storagelens", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_access_point_policy(policy, name, x-amz-account-id)
    put_access_point_policy(policy, name, x-amz-account-id, params::Dict{String,<:Any})

Associates an access policy with the specified access point. Each access point can have
only one policy, so a request made to this API replaces any existing policy associated with
the specified access point.  All Amazon S3 on Outposts REST API requests for this action
require an additional parameter of x-amz-outpost-id to be passed with the request and an S3
on Outposts endpoint hostname prefix instead of s3-control. For an example of the request
syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and
the x-amz-outpost-id derived using the access point ARN, see the Examples section. The
following actions are related to PutAccessPointPolicy:    GetAccessPointPolicy
DeleteAccessPointPolicy

# Arguments
- `policy`: The policy that you want to apply to the specified access point. For more
  information about access point policies, see Managing data access with Amazon S3 Access
  Points in the Amazon Simple Storage Service User Guide.
- `name`: The name of the access point that you want to associate with the specified
  policy. For using this parameter with Amazon S3 on Outposts with the REST API, you must
  specify the name and the x-amz-outpost-id as well. For using this parameter with S3 on
  Outposts with the AWS SDK and CLI, you must specify the ARN of the access point accessed in
  the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint
  /<my-accesspoint-name>. For example, to access the access point reports-ap through
  outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding
  of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap.
  The value must be URL encoded.
- `x-amz-account-id`: The AWS account ID for owner of the bucket associated with the
  specified access point.

"""
put_access_point_policy(Policy, name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}("Policy"=>Policy, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_access_point_policy(Policy, name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/accesspoint/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Policy"=>Policy, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_bucket_lifecycle_configuration(name, x-amz-account-id)
    put_bucket_lifecycle_configuration(name, x-amz-account-id, params::Dict{String,<:Any})

 This action puts a lifecycle configuration to an Amazon S3 on Outposts bucket. To put a
lifecycle configuration to an S3 bucket, see PutBucketLifecycleConfiguration in the Amazon
Simple Storage Service API.   Creates a new lifecycle configuration for the Outposts bucket
or replaces an existing lifecycle configuration. Outposts buckets only support lifecycle
configurations that delete/expire objects after a certain period of time and abort
incomplete multipart uploads. For more information, see Managing Lifecycle Permissions for
Amazon S3 on Outposts.  All Amazon S3 on Outposts REST API requests for this action require
an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on
Outposts endpoint hostname prefix instead of s3-control. For an example of the request
syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and
the x-amz-outpost-id derived using the access point ARN, see the Examples section. The
following actions are related to PutBucketLifecycleConfiguration:
GetBucketLifecycleConfiguration     DeleteBucketLifecycleConfiguration

# Arguments
- `name`: The name of the bucket for which to set the configuration.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"LifecycleConfiguration"`: Container for lifecycle rules. You can add as many as 1,000
  rules.
"""
put_bucket_lifecycle_configuration(name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_bucket_lifecycle_configuration(name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/lifecycleconfiguration", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_bucket_policy(policy, name, x-amz-account-id)
    put_bucket_policy(policy, name, x-amz-account-id, params::Dict{String,<:Any})

 This action puts a bucket policy to an Amazon S3 on Outposts bucket. To put a policy on an
S3 bucket, see PutBucketPolicy in the Amazon Simple Storage Service API.   Applies an
Amazon S3 bucket policy to an Outposts bucket. For more information, see Using Amazon S3 on
Outposts in the Amazon Simple Storage Service User Guide. If you are using an identity
other than the root user of the AWS account that owns the Outposts bucket, the calling
identity must have the PutBucketPolicy permissions on the specified Outposts bucket and
belong to the bucket owner's account in order to use this action. If you don't have
PutBucketPolicy permissions, Amazon S3 returns a 403 Access Denied error. If you have the
correct permissions, but you're not using an identity that belongs to the bucket owner's
account, Amazon S3 returns a 405 Method Not Allowed error.   As a security precaution, the
root user of the AWS account that owns a bucket can always use this action, even if the
policy explicitly denies the root user the ability to perform this action.   For more
information about bucket policies, see Using Bucket Policies and User Policies. All Amazon
S3 on Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to PutBucketPolicy:    GetBucketPolicy     DeleteBucketPolicy

# Arguments
- `policy`: The bucket policy as a JSON document.
- `name`: Specifies the bucket. For using this parameter with Amazon S3 on Outposts with
  the REST API, you must specify the name and the x-amz-outpost-id as well. For using this
  parameter with S3 on Outposts with the AWS SDK and CLI, you must specify the ARN of the
  bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"x-amz-confirm-remove-self-bucket-access"`: Set this parameter to true to confirm that
  you want to remove your permissions to change this bucket policy in the future.  This is
  not supported by Amazon S3 on Outposts buckets.
"""
put_bucket_policy(Policy, name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/policy", Dict{String, Any}("Policy"=>Policy, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_bucket_policy(Policy, name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/policy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Policy"=>Policy, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_bucket_tagging(tagging, name, x-amz-account-id)
    put_bucket_tagging(tagging, name, x-amz-account-id, params::Dict{String,<:Any})

 This action puts tags on an Amazon S3 on Outposts bucket. To put tags on an S3 bucket, see
PutBucketTagging in the Amazon Simple Storage Service API.   Sets the tags for an Outposts
bucket. For more information, see Using Amazon S3 on Outposts in the Amazon Simple Storage
Service User Guide. Use tags to organize your AWS bill to reflect your own cost structure.
To do this, sign up to get your AWS account bill with tag key values included. Then, to see
the cost of combined resources, organize your billing information according to resources
with the same tag key values. For example, you can tag several resources with a specific
application name, and then organize your billing information to see the total cost of that
application across several services. For more information, see Cost Allocation and Tagging.
 Within a bucket, if you add a tag that has the same key as an existing tag, the new value
overwrites the old value. For more information, see  Using Cost Allocation in Amazon S3
Bucket Tags.  To use this action, you must have permissions to perform the
s3-outposts:PutBucketTagging action. The Outposts bucket owner has this permission by
default and can grant this permission to others. For more information about permissions,
see  Permissions Related to Bucket Subresource Operations and Managing Access Permissions
to Your Amazon S3 Resources.  PutBucketTagging has the following special errors:   Error
code: InvalidTagError    Description: The tag provided was not a valid tag. This error can
occur if the tag did not pass input validation. For information about tag restrictions, see
 User-Defined Tag Restrictions and  AWS-Generated Cost Allocation Tag Restrictions.
Error code: MalformedXMLError    Description: The XML provided does not match the schema.
  Error code: OperationAbortedError     Description: A conflicting conditional action is
currently in progress against this resource. Try again.     Error code: InternalError
Description: The service was unable to apply the provided tag to the bucket.     All Amazon
S3 on Outposts REST API requests for this action require an additional parameter of
x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname
prefix instead of s3-control. For an example of the request syntax for Amazon S3 on
Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id
derived using the access point ARN, see the Examples section. The following actions are
related to PutBucketTagging:    GetBucketTagging     DeleteBucketTagging

# Arguments
- `tagging`:
- `name`: The Amazon Resource Name (ARN) of the bucket. For using this parameter with
  Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id
  as well. For using this parameter with S3 on Outposts with the AWS SDK and CLI, you must
  specify the ARN of the bucket accessed in the format
  arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/&lt
  ;my-bucket-name>. For example, to access the bucket reports through outpost my-outpost
  owned by account 123456789012 in Region us-west-2, use the URL encoding of
  arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value
  must be URL encoded.
- `x-amz-account-id`: The AWS account ID of the Outposts bucket.

"""
put_bucket_tagging(Tagging, name, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}("Tagging"=>Tagging, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_bucket_tagging(Tagging, name, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/bucket/$(name)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Tagging"=>Tagging, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_job_tagging(tags, id, x-amz-account-id)
    put_job_tagging(tags, id, x-amz-account-id, params::Dict{String,<:Any})

Sets the supplied tag-set on an S3 Batch Operations job. A tag is a key-value pair. You can
associate S3 Batch Operations tags with any job by sending a PUT request against the
tagging subresource that is associated with the job. To modify the existing tag set, you
can either replace the existing tag set entirely, or make changes within the existing tag
set by retrieving the existing tag set using GetJobTagging, modify that tag set, and use
this action to replace the tag set with the one you modified. For more information, see
Controlling access and labeling jobs using tags in the Amazon Simple Storage Service User
Guide.      If you send this request with an empty tag set, Amazon S3 deletes the existing
tag set on the Batch Operations job. If you use this method, you are charged for a Tier 1
Request (PUT). For more information, see Amazon S3 pricing.   For deleting existing tags
for your Batch Operations job, a DeleteJobTagging request is preferred because it achieves
the same result without incurring charges.   A few things to consider about using tags:
Amazon S3 limits the maximum number of tags to 50 tags per job.   You can associate up to
50 tags with a job as long as they have unique tag keys.   A tag key can be up to 128
Unicode characters in length, and tag values can be up to 256 Unicode characters in length.
  The key and values are case sensitive.   For tagging-related restrictions related to
characters and encodings, see User-Defined Tag Restrictions in the AWS Billing and Cost
Management User Guide.       To use this action, you must have permission to perform the
s3:PutJobTagging action. Related actions include:    CreatJob     GetJobTagging
DeleteJobTagging

# Arguments
- `tags`: The set of tags to associate with the S3 Batch Operations job.
- `id`: The ID for the S3 Batch Operations job whose tags you want to replace.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

"""
put_job_tagging(Tags, id, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}("Tags"=>Tags, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_job_tagging(Tags, id, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/jobs/$(id)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Tags"=>Tags, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_public_access_block(public_access_block_configuration, x-amz-account-id)
    put_public_access_block(public_access_block_configuration, x-amz-account-id, params::Dict{String,<:Any})

Creates or modifies the PublicAccessBlock configuration for an AWS account. For more
information, see  Using Amazon S3 block public access. Related actions include:
GetPublicAccessBlock     DeletePublicAccessBlock

# Arguments
- `public_access_block_configuration`: The PublicAccessBlock configuration that you want to
  apply to the specified AWS account.
- `x-amz-account-id`: The account ID for the AWS account whose PublicAccessBlock
  configuration you want to set.

"""
put_public_access_block(PublicAccessBlockConfiguration, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}("PublicAccessBlockConfiguration"=>PublicAccessBlockConfiguration, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_public_access_block(PublicAccessBlockConfiguration, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/configuration/publicAccessBlock", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("PublicAccessBlockConfiguration"=>PublicAccessBlockConfiguration, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_storage_lens_configuration(storage_lens_configuration, storagelensid, x-amz-account-id)
    put_storage_lens_configuration(storage_lens_configuration, storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Puts an Amazon S3 Storage Lens configuration. For more information about S3 Storage Lens,
see Working with Amazon S3 Storage Lens in the Amazon Simple Storage Service User Guide.
To use this action, you must have permission to perform the s3:PutStorageLensConfiguration
action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the
Amazon Simple Storage Service User Guide.

# Arguments
- `storage_lens_configuration`: The S3 Storage Lens configuration.
- `storagelensid`: The ID of the S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tag set of the S3 Storage Lens configuration.  You can set up to a maximum
  of 50 tags.
"""
put_storage_lens_configuration(StorageLensConfiguration, storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}("StorageLensConfiguration"=>StorageLensConfiguration, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_storage_lens_configuration(StorageLensConfiguration, storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/storagelens/$(storagelensid)", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("StorageLensConfiguration"=>StorageLensConfiguration, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    put_storage_lens_configuration_tagging(tag, storagelensid, x-amz-account-id)
    put_storage_lens_configuration_tagging(tag, storagelensid, x-amz-account-id, params::Dict{String,<:Any})

Put or replace tags on an existing Amazon S3 Storage Lens configuration. For more
information about S3 Storage Lens, see Assessing your storage activity and usage with
Amazon S3 Storage Lens  in the Amazon Simple Storage Service User Guide.  To use this
action, you must have permission to perform the s3:PutStorageLensConfigurationTagging
action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the
Amazon Simple Storage Service User Guide.

# Arguments
- `tag`: The tag set of the S3 Storage Lens configuration.  You can set up to a maximum of
  50 tags.
- `storagelensid`: The ID of the S3 Storage Lens configuration.
- `x-amz-account-id`: The account ID of the requester.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: The tag set of the S3 Storage Lens configuration.  You can set up to a maximum
  of 50 tags.
"""
put_storage_lens_configuration_tagging(Tag, storagelensid, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}("Tag"=>Tag, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
put_storage_lens_configuration_tagging(Tag, storagelensid, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("PUT", "/v20180820/storagelens/$(storagelensid)/tagging", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Tag"=>Tag, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    update_job_priority(id, priority, x-amz-account-id)
    update_job_priority(id, priority, x-amz-account-id, params::Dict{String,<:Any})

Updates an existing S3 Batch Operations job's priority. For more information, see S3 Batch
Operations in the Amazon Simple Storage Service User Guide.  Related actions include:
CreateJob     ListJobs     DescribeJob     UpdateJobStatus

# Arguments
- `id`: The ID for the job whose priority you want to update.
- `priority`: The priority you want to assign to this job.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

"""
update_job_priority(id, priority, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs/$(id)/priority", Dict{String, Any}("priority"=>priority, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
update_job_priority(id, priority, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs/$(id)/priority", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("priority"=>priority, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)

"""
    update_job_status(id, requested_job_status, x-amz-account-id)
    update_job_status(id, requested_job_status, x-amz-account-id, params::Dict{String,<:Any})

Updates the status for the specified job. Use this action to confirm that you want to run a
job or to cancel an existing job. For more information, see S3 Batch Operations in the
Amazon Simple Storage Service User Guide.  Related actions include:    CreateJob
ListJobs     DescribeJob     UpdateJobStatus

# Arguments
- `id`: The ID of the job whose status you want to update.
- `requested_job_status`: The status that you want to move the specified job to.
- `x-amz-account-id`: The AWS account ID associated with the S3 Batch Operations job.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"statusUpdateReason"`: A description of the reason why you want to change the specified
  job's status. This field can be any string up to the maximum length.
"""
update_job_status(id, requestedJobStatus, x_amz_account_id; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs/$(id)/status", Dict{String, Any}("requestedJobStatus"=>requestedJobStatus, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)); aws_config=aws_config)
update_job_status(id, requestedJobStatus, x_amz_account_id, params::AbstractDict{String, <:Any}; aws_config::AbstractAWSConfig=global_aws_config()) = s3_control("POST", "/v20180820/jobs/$(id)/status", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("requestedJobStatus"=>requestedJobStatus, "headers"=>Dict{String, Any}("x-amz-account-id"=>x_amz_account_id)), params)); aws_config=aws_config)


text:
"""`sminreal(sys)`

Compute the structurally minimal realization of the state-space system `sys`. A
structurally minimal realization is one where only states that can be
determined to be uncontrollable and unobservable based on the location of 0s in
`sys` are removed."""
function sminreal(sys::StateSpace)
    A, B, C, inds = struct_ctrb_obsv(sys)
    return StateSpace(A, B, C, sys.D, sys.Ts)
end

# Determine the structurally controllable and observable realization for the system
struct_ctrb_obsv(sys::StateSpace) = struct_ctrb_obsv(sys.A, sys.B, sys.C)
function struct_ctrb_obsv(A::AbstractVecOrMat, B::AbstractVecOrMat, C::AbstractVecOrMat)
    costates = struct_ctrb_states(A, B) .& struct_ctrb_states(A', C')
    if !all(costates)
        inds = findall(costates)
        return A[inds, inds], B[inds, :], C[:, inds], inds
    else
        return A, B, C, [1:size(A, 1);]
    end
end

# Compute a bit-vector, expressing whether a state of the pair (A, B) is
# structurally controllable.
function struct_ctrb_states(A::AbstractVecOrMat, B::AbstractVecOrMat)
    bitA = A .!= 0
    d_cvec = cvec = vec(any(B .!= 0, dims=2))
    while any(d_cvec .!= 0)
        Adcvec = vec(any(bitA[:, findall(d_cvec)], dims=2))
        cvec = cvec .| Adcvec
        d_cvec = Adcvec .& .~cvec
    end
    return cvec
end


text:
facts("next prime") do

  @fact next_prime(1) => 2
  @fact next_prime(2) => 3
  @fact next_prime(3) => 5
  @fact next_prime(4) => 5
  @fact next_prime(5) => 7
  @fact next_prime(6) => 7
  @fact next_prime(7) => 11
  @fact next_prime(8) => 11
  @fact next_prime(9) => 11
  @fact next_prime(10) => 11
  @fact next_prime(11) => 13
  @fact next_prime(13) => 17
  @fact next_prime(16) => 17
  @fact next_prime(17) => 19
  @fact next_prime(19) => 23
  @fact next_prime(49) => 53

  @fact next_prime(BigInt(49)) => 53

end