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

"""
    cancel_rotate_secret(secret_id)
    cancel_rotate_secret(secret_id, params::Dict{String,<:Any})

Disables automatic scheduled rotation and cancels the rotation of a secret if currently in
progress. To re-enable scheduled rotation, call RotateSecret with
AutomaticallyRotateAfterDays set to a value greater than 0. This immediately rotates your
secret and then enables the automatic schedule.  If you cancel a rotation while in
progress, it can leave the VersionStage labels in an unexpected state. Depending on the
step of the rotation in progress, you might need to remove the staging label AWSPENDING
from the partially created version, specified by the VersionId response value. You should
also evaluate the partially rotated new version to see if it should be deleted, which you
can do by removing all staging labels from the new version VersionStage field.  To
successfully start a rotation, the staging label AWSPENDING must be in one of the following
states:   Not attached to any version at all   Attached to the same version as the staging
label AWSCURRENT    If the staging label AWSPENDING attached to a different version than
the version with AWSCURRENT then the attempt to rotate fails.  Minimum permissions  To run
this command, you must have the following permissions:   secretsmanager:CancelRotateSecret
  Related operations    To configure rotation for a secret or to manually trigger a
rotation, use RotateSecret.   To get the rotation configuration details for a secret, use
DescribeSecret.   To list all of the currently available secrets, use ListSecrets.   To
list all of the versions currently associated with a secret, use ListSecretVersionIds.

# Arguments
- `secret_id`: Specifies the secret to cancel a rotation request. You can specify either
  the Amazon Resource Name (ARN) or the friendly name of the secret.  If you specify an ARN,
  we generally recommend that you specify a complete ARN. You can specify a partial ARN
  too—for example, if you don’t include the final hyphen and six random characters that
  Secrets Manager adds at the end of the ARN when you created the secret. A partial ARN match
  can work as long as it uniquely matches only one secret. However, if your secret has a name
  that ends in a hyphen followed by six characters (before Secrets Manager adds the hyphen
  and six characters to the ARN) and you try to use that as a partial ARN, then those
  characters cause Secrets Manager to assume that you’re specifying a complete ARN. This
  confusion can cause unexpected results. To avoid this situation, we recommend that you
  don’t create secret names ending with a hyphen followed by six characters. If you specify
  an incomplete ARN without the random suffix, and instead provide the 'friendly name', you
  must not include the random suffix. If you do include the random suffix added by Secrets
  Manager, you receive either a ResourceNotFoundException or an AccessDeniedException error,
  depending on your permissions.

"""
cancel_rotate_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("CancelRotateSecret", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
cancel_rotate_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("CancelRotateSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

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

Creates a new secret. A secret in Secrets Manager consists of both the protected secret
data and the important information needed to manage the secret. Secrets Manager stores the
encrypted secret data in one of a collection of \"versions\" associated with the secret.
Each version contains a copy of the encrypted secret data. Each version is associated with
one or more \"staging labels\" that identify where the version is in the rotation cycle.
The SecretVersionsToStages field of the secret contains the mapping of staging labels to
the active versions of the secret. Versions without a staging label are considered
deprecated and not included in the list. You provide the secret data to be encrypted by
putting text in either the SecretString parameter or binary data in the SecretBinary
parameter, but not both. If you include SecretString or SecretBinary then Secrets Manager
also creates an initial secret version and automatically attaches the staging label
AWSCURRENT to the new version.    If you call an operation to encrypt or decrypt the
SecretString or SecretBinary for a secret in the same account as the calling user and that
secret doesn't specify a AWS KMS encryption key, Secrets Manager uses the account's default
AWS managed customer master key (CMK) with the alias aws/secretsmanager. If this key
doesn't already exist in your account then Secrets Manager creates it for you
automatically. All users and roles in the same AWS account automatically have access to use
the default CMK. Note that if an Secrets Manager API call results in AWS creating the
account's AWS-managed CMK, it can result in a one-time significant delay in returning the
result.   If the secret resides in a different AWS account from the credentials calling an
API that requires encryption or decryption of the secret value then you must create and use
a custom AWS KMS CMK because you can't access the default CMK for the account using
credentials from a different AWS account. Store the ARN of the CMK in the secret when you
create the secret or when you update it by including it in the KMSKeyId. If you call an API
that must encrypt or decrypt SecretString or SecretBinary using credentials from a
different account then the AWS KMS key policy must grant cross-account access to that other
account's user or role for both the kms:GenerateDataKey and kms:Decrypt operations.
Minimum permissions  To run this command, you must have the following permissions:
secretsmanager:CreateSecret   kms:GenerateDataKey - needed only if you use a
customer-managed AWS KMS key to encrypt the secret. You do not need this permission to use
the account default AWS managed CMK for Secrets Manager.   kms:Decrypt - needed only if you
use a customer-managed AWS KMS key to encrypt the secret. You do not need this permission
to use the account default AWS managed CMK for Secrets Manager.
secretsmanager:TagResource - needed only if you include the Tags parameter.     Related
operations    To delete a secret, use DeleteSecret.   To modify an existing secret, use
UpdateSecret.   To create a new version of a secret, use PutSecretValue.   To retrieve the
encrypted secure string and secure binary values, use GetSecretValue.   To retrieve all
other details for a secret, use DescribeSecret. This does not include the encrypted secure
string and secure binary values.   To retrieve the list of secret versions associated with
the current secret, use DescribeSecret and examine the SecretVersionsToStages response
value.

# Arguments
- `name`: Specifies the friendly name of the new secret. The secret name must be ASCII
  letters, digits, or the following characters : /_+=.@-  Do not end your secret name with a
  hyphen followed by six characters. If you do so, you risk confusion and unexpected results
  when searching for a secret by partial ARN. Secrets Manager automatically adds a hyphen and
  six random characters at the end of the ARN.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AddReplicaRegions"`: (Optional) Add a list of regions to replicate secrets. Secrets
  Manager replicates the KMSKeyID objects to the list of regions specified in the parameter.
- `"ClientRequestToken"`: (Optional) If you include SecretString or SecretBinary, then an
  initial version is created as part of the secret, and this parameter specifies a unique
  identifier for the new version.   If you use the AWS CLI or one of the AWS SDK to call this
  operation, then you can leave this parameter empty. The CLI or SDK generates a random UUID
  for you and includes it as the value for this parameter in the request. If you don't use
  the SDK and instead generate a raw HTTP request to the Secrets Manager service endpoint,
  then you must generate a ClientRequestToken yourself for the new version and include the
  value in the request.  This value helps ensure idempotency. Secrets Manager uses this value
  to prevent the accidental creation of duplicate versions if there are failures and retries
  during a rotation. We recommend that you generate a UUID-type value to ensure uniqueness of
  your versions within the specified secret.    If the ClientRequestToken value isn't already
  associated with a version of the secret then a new version of the secret is created.    If
  a version with this value already exists and the version SecretString and SecretBinary
  values are the same as those in the request, then the request is ignored.   If a version
  with this value already exists and that version's SecretString and SecretBinary values are
  different from those in the request, then the request fails because you cannot modify an
  existing version. Instead, use PutSecretValue to create a new version.   This value becomes
  the VersionId of the new version.
- `"Description"`: (Optional) Specifies a user-provided description of the secret.
- `"ForceOverwriteReplicaSecret"`: (Optional) If set, the replication overwrites a secret
  with the same name in the destination region.
- `"KmsKeyId"`: (Optional) Specifies the ARN, Key ID, or alias of the AWS KMS customer
  master key (CMK) to be used to encrypt the SecretString or SecretBinary values in the
  versions stored in this secret. You can specify any of the supported ways to identify a AWS
  KMS key ID. If you need to reference a CMK in a different account, you can use only the key
  ARN or the alias ARN. If you don't specify this value, then Secrets Manager defaults to
  using the AWS account's default CMK (the one named aws/secretsmanager). If a AWS KMS CMK
  with that name doesn't yet exist, then Secrets Manager creates it for you automatically the
  first time it needs to encrypt a version's SecretString or SecretBinary fields.  You can
  use the account default CMK to encrypt and decrypt only if you call this operation using
  credentials from the same account that owns the secret. If the secret resides in a
  different account, then you must create a custom CMK and specify the ARN in this field.
- `"SecretBinary"`: (Optional) Specifies binary data that you want to encrypt and store in
  the new version of the secret. To use this parameter in the command-line tools, we
  recommend that you store your binary data in a file and then use the appropriate technique
  for your tool to pass the contents of the file as a parameter. Either SecretString or
  SecretBinary must have a value, but not both. They cannot both be empty. This parameter is
  not available using the Secrets Manager console. It can be accessed only by using the AWS
  CLI or one of the AWS SDKs.
- `"SecretString"`: (Optional) Specifies text data that you want to encrypt and store in
  this new version of the secret. Either SecretString or SecretBinary must have a value, but
  not both. They cannot both be empty. If you create a secret by using the Secrets Manager
  console then Secrets Manager puts the protected secret text in only the SecretString
  parameter. The Secrets Manager console stores the information as a JSON structure of
  key/value pairs that the Lambda rotation function knows how to parse. For storing multiple
  values, we recommend that you use a JSON text string argument and specify key/value pairs.
  For information on how to format a JSON parameter for the various command line tool
  environments, see Using JSON for Parameters in the AWS CLI User Guide. For example:
  {\"username\":\"bob\",\"password\":\"abc123xyz456\"}  If your command-line tool or SDK
  requires quotation marks around the parameter, you should use single quotes to avoid
  confusion with the double quotes required in the JSON text.
- `"Tags"`: (Optional) Specifies a list of user-defined tags that are attached to the
  secret. Each tag is a \"Key\" and \"Value\" pair of strings. This operation only appends
  tags to the existing list of tags. To remove tags, you must use UntagResource.    Secrets
  Manager tag key names are case sensitive. A tag with the key \"ABC\" is a different tag
  from one with key \"abc\".   If you check tags in IAM policy Condition elements as part of
  your security strategy, then adding or removing a tag can change permissions. If the
  successful completion of this operation would result in you losing your permissions for
  this secret, then this operation is blocked and returns an Access Denied error.    This
  parameter requires a JSON text string argument. For information on how to format a JSON
  parameter for the various command line tool environments, see Using JSON for Parameters in
  the AWS CLI User Guide. For example:
  [{\"Key\":\"CostCenter\",\"Value\":\"12345\"},{\"Key\":\"environment\",\"Value\":\"productio
  n\"}]  If your command-line tool or SDK requires quotation marks around the parameter, you
  should use single quotes to avoid confusion with the double quotes required in the JSON
  text.  The following basic restrictions apply to tags:   Maximum number of tags per
  secret—50   Maximum key length—127 Unicode characters in UTF-8   Maximum value
  length—255 Unicode characters in UTF-8   Tag keys and values are case sensitive.   Do not
  use the aws: prefix in your tag names or values because AWS reserves it for AWS use. You
  can't edit or delete tag names or values with this prefix. Tags with this prefix do not
  count against your tags per secret limit.   If you use your tagging schema across multiple
  services and resources, remember other services might have restrictions on allowed
  characters. Generally allowed characters: letters, spaces, and numbers representable in
  UTF-8, plus the following special characters: + - = . _ : / @.
"""
create_secret(Name; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("CreateSecret", Dict{String, Any}("Name"=>Name, "ClientRequestToken"=>string(uuid4())); aws_config=aws_config)
create_secret(Name, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("CreateSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("Name"=>Name, "ClientRequestToken"=>string(uuid4())), params)); aws_config=aws_config)

"""
    delete_resource_policy(secret_id)
    delete_resource_policy(secret_id, params::Dict{String,<:Any})

Deletes the resource-based permission policy attached to the secret.  Minimum permissions
To run this command, you must have the following permissions:
secretsmanager:DeleteResourcePolicy    Related operations    To attach a resource policy to
a secret, use PutResourcePolicy.   To retrieve the current resource-based policy attached
to a secret, use GetResourcePolicy.   To list all of the currently available secrets, use
ListSecrets.

# Arguments
- `secret_id`: Specifies the secret that you want to delete the attached resource-based
  policy for. You can specify either the Amazon Resource Name (ARN) or the friendly name of
  the secret.  If you specify an ARN, we generally recommend that you specify a complete ARN.
  You can specify a partial ARN too—for example, if you don’t include the final hyphen
  and six random characters that Secrets Manager adds at the end of the ARN when you created
  the secret. A partial ARN match can work as long as it uniquely matches only one secret.
  However, if your secret has a name that ends in a hyphen followed by six characters (before
  Secrets Manager adds the hyphen and six characters to the ARN) and you try to use that as a
  partial ARN, then those characters cause Secrets Manager to assume that you’re specifying
  a complete ARN. This confusion can cause unexpected results. To avoid this situation, we
  recommend that you don’t create secret names ending with a hyphen followed by six
  characters. If you specify an incomplete ARN without the random suffix, and instead provide
  the 'friendly name', you must not include the random suffix. If you do include the random
  suffix added by Secrets Manager, you receive either a ResourceNotFoundException or an
  AccessDeniedException error, depending on your permissions.

"""
delete_resource_policy(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DeleteResourcePolicy", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
delete_resource_policy(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DeleteResourcePolicy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    delete_secret(secret_id)
    delete_secret(secret_id, params::Dict{String,<:Any})

Deletes an entire secret and all of the versions. You can optionally include a recovery
window during which you can restore the secret. If you don't specify a recovery window
value, the operation defaults to 30 days. Secrets Manager attaches a DeletionDate stamp to
the secret that specifies the end of the recovery window. At the end of the recovery
window, Secrets Manager deletes the secret permanently. At any time before recovery window
ends, you can use RestoreSecret to remove the DeletionDate and cancel the deletion of the
secret. You cannot access the encrypted secret information in any secret scheduled for
deletion. If you need to access that information, you must cancel the deletion with
RestoreSecret and then retrieve the information.    There is no explicit operation to
delete a version of a secret. Instead, remove all staging labels from the VersionStage
field of a version. That marks the version as deprecated and allows Secrets Manager to
delete it as needed. Versions without any staging labels do not show up in
ListSecretVersionIds unless you specify IncludeDeprecated.   The permanent secret deletion
at the end of the waiting period is performed as a background task with low priority. There
is no guarantee of a specific time after the recovery window for the actual delete
operation to occur.     Minimum permissions  To run this command, you must have the
following permissions:   secretsmanager:DeleteSecret    Related operations    To create a
secret, use CreateSecret.   To cancel deletion of a version of a secret before the recovery
window has expired, use RestoreSecret.

# Arguments
- `secret_id`: Specifies the secret to delete. You can specify either the Amazon Resource
  Name (ARN) or the friendly name of the secret.  If you specify an ARN, we generally
  recommend that you specify a complete ARN. You can specify a partial ARN too—for example,
  if you don’t include the final hyphen and six random characters that Secrets Manager adds
  at the end of the ARN when you created the secret. A partial ARN match can work as long as
  it uniquely matches only one secret. However, if your secret has a name that ends in a
  hyphen followed by six characters (before Secrets Manager adds the hyphen and six
  characters to the ARN) and you try to use that as a partial ARN, then those characters
  cause Secrets Manager to assume that you’re specifying a complete ARN. This confusion can
  cause unexpected results. To avoid this situation, we recommend that you don’t create
  secret names ending with a hyphen followed by six characters. If you specify an incomplete
  ARN without the random suffix, and instead provide the 'friendly name', you must not
  include the random suffix. If you do include the random suffix added by Secrets Manager,
  you receive either a ResourceNotFoundException or an AccessDeniedException error, depending
  on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceDeleteWithoutRecovery"`: (Optional) Specifies that the secret is to be deleted
  without any recovery window. You can't use both this parameter and the RecoveryWindowInDays
  parameter in the same API call. An asynchronous background process performs the actual
  deletion, so there can be a short delay before the operation completes. If you write code
  to delete and then immediately recreate a secret with the same name, ensure that your code
  includes appropriate back off and retry logic.  Use this parameter with caution. This
  parameter causes the operation to skip the normal waiting period before the permanent
  deletion that AWS would normally impose with the RecoveryWindowInDays parameter. If you
  delete a secret with the ForceDeleteWithouRecovery parameter, then you have no opportunity
  to recover the secret. You lose the secret permanently.   If you use this parameter and
  include a previously deleted or nonexistent secret, the operation does not return the error
  ResourceNotFoundException in order to correctly handle retries.
- `"RecoveryWindowInDays"`: (Optional) Specifies the number of days that Secrets Manager
  waits before Secrets Manager can delete the secret. You can't use both this parameter and
  the ForceDeleteWithoutRecovery parameter in the same API call. This value can range from 7
  to 30 days with a default value of 30.
"""
delete_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DeleteSecret", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
delete_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DeleteSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    describe_secret(secret_id)
    describe_secret(secret_id, params::Dict{String,<:Any})

Retrieves the details of a secret. It does not include the encrypted fields. Secrets
Manager only returns fields populated with a value in the response.   Minimum permissions
To run this command, you must have the following permissions:
secretsmanager:DescribeSecret    Related operations    To create a secret, use
CreateSecret.   To modify a secret, use UpdateSecret.   To retrieve the encrypted secret
information in a version of the secret, use GetSecretValue.   To list all of the secrets in
the AWS account, use ListSecrets.

# Arguments
- `secret_id`: The identifier of the secret whose details you want to retrieve. You can
  specify either the Amazon Resource Name (ARN) or the friendly name of the secret.  If you
  specify an ARN, we generally recommend that you specify a complete ARN. You can specify a
  partial ARN too—for example, if you don’t include the final hyphen and six random
  characters that Secrets Manager adds at the end of the ARN when you created the secret. A
  partial ARN match can work as long as it uniquely matches only one secret. However, if your
  secret has a name that ends in a hyphen followed by six characters (before Secrets Manager
  adds the hyphen and six characters to the ARN) and you try to use that as a partial ARN,
  then those characters cause Secrets Manager to assume that you’re specifying a complete
  ARN. This confusion can cause unexpected results. To avoid this situation, we recommend
  that you don’t create secret names ending with a hyphen followed by six characters. If
  you specify an incomplete ARN without the random suffix, and instead provide the 'friendly
  name', you must not include the random suffix. If you do include the random suffix added by
  Secrets Manager, you receive either a ResourceNotFoundException or an AccessDeniedException
  error, depending on your permissions.

"""
describe_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DescribeSecret", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
describe_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("DescribeSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

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

Generates a random password of the specified complexity. This operation is intended for use
in the Lambda rotation function. Per best practice, we recommend that you specify the
maximum length and include every character type that the system you are generating a
password for can support.  Minimum permissions  To run this command, you must have the
following permissions:   secretsmanager:GetRandomPassword

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ExcludeCharacters"`: A string that includes characters that should not be included in
  the generated password. The default is that all characters from the included sets can be
  used.
- `"ExcludeLowercase"`: Specifies that the generated password should not include lowercase
  letters. The default if you do not include this switch parameter is that lowercase letters
  can be included.
- `"ExcludeNumbers"`: Specifies that the generated password should not include digits. The
  default if you do not include this switch parameter is that digits can be included.
- `"ExcludePunctuation"`: Specifies that the generated password should not include
  punctuation characters. The default if you do not include this switch parameter is that
  punctuation characters can be included. The following are the punctuation characters that
  can be included in the generated password if you don't explicitly exclude them with
  ExcludeCharacters or ExcludePunctuation:  ! \" #  % & ' ( ) * + , - . / : ; < = >
  ? @ [  ] ^ _ ` { | } ~
- `"ExcludeUppercase"`: Specifies that the generated password should not include uppercase
  letters. The default if you do not include this switch parameter is that uppercase letters
  can be included.
- `"IncludeSpace"`: Specifies that the generated password can include the space character.
  The default if you do not include this switch parameter is that the space character is not
  included.
- `"PasswordLength"`: The desired length of the generated password. The default value if
  you do not include this parameter is 32 characters.
- `"RequireEachIncludedType"`: A boolean value that specifies whether the generated
  password must include at least one of every allowed character type. The default value is
  True and the operation requires at least one of every character type.
"""
get_random_password(; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetRandomPassword"; aws_config=aws_config)
get_random_password(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetRandomPassword", params; aws_config=aws_config)

"""
    get_resource_policy(secret_id)
    get_resource_policy(secret_id, params::Dict{String,<:Any})

Retrieves the JSON text of the resource-based policy document attached to the specified
secret. The JSON request string input and response output displays formatted code with
white space and line breaks for better readability. Submit your input as a single line JSON
string.  Minimum permissions  To run this command, you must have the following permissions:
  secretsmanager:GetResourcePolicy    Related operations    To attach a resource policy to
a secret, use PutResourcePolicy.   To delete the resource-based policy attached to a
secret, use DeleteResourcePolicy.   To list all of the currently available secrets, use
ListSecrets.

# Arguments
- `secret_id`: Specifies the secret that you want to retrieve the attached resource-based
  policy for. You can specify either the Amazon Resource Name (ARN) or the friendly name of
  the secret.  If you specify an ARN, we generally recommend that you specify a complete ARN.
  You can specify a partial ARN too—for example, if you don’t include the final hyphen
  and six random characters that Secrets Manager adds at the end of the ARN when you created
  the secret. A partial ARN match can work as long as it uniquely matches only one secret.
  However, if your secret has a name that ends in a hyphen followed by six characters (before
  Secrets Manager adds the hyphen and six characters to the ARN) and you try to use that as a
  partial ARN, then those characters cause Secrets Manager to assume that you’re specifying
  a complete ARN. This confusion can cause unexpected results. To avoid this situation, we
  recommend that you don’t create secret names ending with a hyphen followed by six
  characters. If you specify an incomplete ARN without the random suffix, and instead provide
  the 'friendly name', you must not include the random suffix. If you do include the random
  suffix added by Secrets Manager, you receive either a ResourceNotFoundException or an
  AccessDeniedException error, depending on your permissions.

"""
get_resource_policy(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetResourcePolicy", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
get_resource_policy(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetResourcePolicy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    get_secret_value(secret_id)
    get_secret_value(secret_id, params::Dict{String,<:Any})

Retrieves the contents of the encrypted fields SecretString or SecretBinary from the
specified version of a secret, whichever contains content.  Minimum permissions  To run
this command, you must have the following permissions:   secretsmanager:GetSecretValue
kms:Decrypt - required only if you use a customer-managed AWS KMS key to encrypt the
secret. You do not need this permission to use the account's default AWS managed CMK for
Secrets Manager.    Related operations    To create a new version of the secret with
different encrypted information, use PutSecretValue.   To retrieve the non-encrypted
details for the secret, use DescribeSecret.

# Arguments
- `secret_id`: Specifies the secret containing the version that you want to retrieve. You
  can specify either the Amazon Resource Name (ARN) or the friendly name of the secret.  If
  you specify an ARN, we generally recommend that you specify a complete ARN. You can specify
  a partial ARN too—for example, if you don’t include the final hyphen and six random
  characters that Secrets Manager adds at the end of the ARN when you created the secret. A
  partial ARN match can work as long as it uniquely matches only one secret. However, if your
  secret has a name that ends in a hyphen followed by six characters (before Secrets Manager
  adds the hyphen and six characters to the ARN) and you try to use that as a partial ARN,
  then those characters cause Secrets Manager to assume that you’re specifying a complete
  ARN. This confusion can cause unexpected results. To avoid this situation, we recommend
  that you don’t create secret names ending with a hyphen followed by six characters. If
  you specify an incomplete ARN without the random suffix, and instead provide the 'friendly
  name', you must not include the random suffix. If you do include the random suffix added by
  Secrets Manager, you receive either a ResourceNotFoundException or an AccessDeniedException
  error, depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VersionId"`: Specifies the unique identifier of the version of the secret that you want
  to retrieve. If you specify both this parameter and VersionStage, the two parameters must
  refer to the same secret version. If you don't specify either a VersionStage or VersionId
  then the default is to perform the operation on the version with the VersionStage value of
  AWSCURRENT. This value is typically a UUID-type value with 32 hexadecimal digits.
- `"VersionStage"`: Specifies the secret version that you want to retrieve by the staging
  label attached to the version. Staging labels are used to keep track of different versions
  during the rotation process. If you specify both this parameter and VersionId, the two
  parameters must refer to the same secret version . If you don't specify either a
  VersionStage or VersionId, then the default is to perform the operation on the version with
  the VersionStage value of AWSCURRENT.
"""
get_secret_value(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetSecretValue", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
get_secret_value(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("GetSecretValue", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    list_secret_version_ids(secret_id)
    list_secret_version_ids(secret_id, params::Dict{String,<:Any})

Lists all of the versions attached to the specified secret. The output does not include the
SecretString or SecretBinary fields. By default, the list includes only versions that have
at least one staging label in VersionStage attached.  Always check the NextToken response
parameter when calling any of the List* operations. These operations can occasionally
return an empty or shorter than expected list of results even when there more results
become available. When this happens, the NextToken response parameter contains a value to
pass to the next call to the same API to request the next part of the list.   Minimum
permissions  To run this command, you must have the following permissions:
secretsmanager:ListSecretVersionIds    Related operations    To list the secrets in an
account, use ListSecrets.

# Arguments
- `secret_id`: The identifier for the secret containing the versions you want to list. You
  can specify either the Amazon Resource Name (ARN) or the friendly name of the secret.  If
  you specify an ARN, we generally recommend that you specify a complete ARN. You can specify
  a partial ARN too—for example, if you don’t include the final hyphen and six random
  characters that Secrets Manager adds at the end of the ARN when you created the secret. A
  partial ARN match can work as long as it uniquely matches only one secret. However, if your
  secret has a name that ends in a hyphen followed by six characters (before Secrets Manager
  adds the hyphen and six characters to the ARN) and you try to use that as a partial ARN,
  then those characters cause Secrets Manager to assume that you’re specifying a complete
  ARN. This confusion can cause unexpected results. To avoid this situation, we recommend
  that you don’t create secret names ending with a hyphen followed by six characters. If
  you specify an incomplete ARN without the random suffix, and instead provide the 'friendly
  name', you must not include the random suffix. If you do include the random suffix added by
  Secrets Manager, you receive either a ResourceNotFoundException or an AccessDeniedException
  error, depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"IncludeDeprecated"`: (Optional) Specifies that you want the results to include versions
  that do not have any staging labels attached to them. Such versions are considered
  deprecated and are subject to deletion by Secrets Manager as needed.
- `"MaxResults"`: (Optional) Limits the number of results you want to include in the
  response. If you don't include this parameter, it defaults to a value that's specific to
  the operation. If additional items exist beyond the maximum you specify, the NextToken
  response element is present and has a value (isn't null). Include that value as the
  NextToken request parameter in the next call to the operation to get the next part of the
  results. Note that Secrets Manager might return fewer results than the maximum even when
  there are more results available. You should check NextToken after every operation to
  ensure that you receive all of the results.
- `"NextToken"`: (Optional) Use this parameter in a request if you receive a NextToken
  response in a previous request indicating there's more output available. In a subsequent
  call, set it to the value of the previous call NextToken response to indicate where the
  output should continue from.
"""
list_secret_version_ids(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ListSecretVersionIds", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
list_secret_version_ids(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ListSecretVersionIds", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

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

Lists all of the secrets that are stored by Secrets Manager in the AWS account. To list the
versions currently stored for a specific secret, use ListSecretVersionIds. The encrypted
fields SecretString and SecretBinary are not included in the output. To get that
information, call the GetSecretValue operation.  Always check the NextToken response
parameter when calling any of the List* operations. These operations can occasionally
return an empty or shorter than expected list of results even when there more results
become available. When this happens, the NextToken response parameter contains a value to
pass to the next call to the same API to request the next part of the list.   Minimum
permissions  To run this command, you must have the following permissions:
secretsmanager:ListSecrets    Related operations    To list the versions attached to a
secret, use ListSecretVersionIds.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: Lists the secret request filters.
- `"MaxResults"`: (Optional) Limits the number of results you want to include in the
  response. If you don't include this parameter, it defaults to a value that's specific to
  the operation. If additional items exist beyond the maximum you specify, the NextToken
  response element is present and has a value (isn't null). Include that value as the
  NextToken request parameter in the next call to the operation to get the next part of the
  results. Note that Secrets Manager might return fewer results than the maximum even when
  there are more results available. You should check NextToken after every operation to
  ensure that you receive all of the results.
- `"NextToken"`: (Optional) Use this parameter in a request if you receive a NextToken
  response in a previous request indicating there's more output available. In a subsequent
  call, set it to the value of the previous call NextToken response to indicate where the
  output should continue from.
- `"SortOrder"`: Lists secrets in the requested order.
"""
list_secrets(; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ListSecrets"; aws_config=aws_config)
list_secrets(params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ListSecrets", params; aws_config=aws_config)

"""
    put_resource_policy(resource_policy, secret_id)
    put_resource_policy(resource_policy, secret_id, params::Dict{String,<:Any})

Attaches the contents of the specified resource-based permission policy to a secret. A
resource-based policy is optional. Alternatively, you can use IAM identity-based policies
that specify the secret's Amazon Resource Name (ARN) in the policy statement's Resources
element. You can also use a combination of both identity-based and resource-based policies.
The affected users and roles receive the permissions that are permitted by all of the
relevant policies. For more information, see Using Resource-Based Policies for AWS Secrets
Manager. For the complete description of the AWS policy syntax and grammar, see IAM JSON
Policy Reference in the IAM User Guide.  Minimum permissions  To run this command, you must
have the following permissions:   secretsmanager:PutResourcePolicy    Related operations
To retrieve the resource policy attached to a secret, use GetResourcePolicy.   To delete
the resource-based policy attached to a secret, use DeleteResourcePolicy.   To list all of
the currently available secrets, use ListSecrets.

# Arguments
- `resource_policy`: A JSON-formatted string constructed according to the grammar and
  syntax for an AWS resource-based policy. The policy in the string identifies who can access
  or manage this secret and its versions. For information on how to format a JSON parameter
  for the various command line tool environments, see Using JSON for Parameters in the AWS
  CLI User Guide.
- `secret_id`: Specifies the secret that you want to attach the resource-based policy. You
  can specify either the ARN or the friendly name of the secret.  If you specify an ARN, we
  generally recommend that you specify a complete ARN. You can specify a partial ARN
  too—for example, if you don’t include the final hyphen and six random characters that
  Secrets Manager adds at the end of the ARN when you created the secret. A partial ARN match
  can work as long as it uniquely matches only one secret. However, if your secret has a name
  that ends in a hyphen followed by six characters (before Secrets Manager adds the hyphen
  and six characters to the ARN) and you try to use that as a partial ARN, then those
  characters cause Secrets Manager to assume that you’re specifying a complete ARN. This
  confusion can cause unexpected results. To avoid this situation, we recommend that you
  don’t create secret names ending with a hyphen followed by six characters. If you specify
  an incomplete ARN without the random suffix, and instead provide the 'friendly name', you
  must not include the random suffix. If you do include the random suffix added by Secrets
  Manager, you receive either a ResourceNotFoundException or an AccessDeniedException error,
  depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"BlockPublicPolicy"`: (Optional) If you set the parameter, BlockPublicPolicy to true,
  then you block resource-based policies that allow broad access to the secret.
"""
put_resource_policy(ResourcePolicy, SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("PutResourcePolicy", Dict{String, Any}("ResourcePolicy"=>ResourcePolicy, "SecretId"=>SecretId); aws_config=aws_config)
put_resource_policy(ResourcePolicy, SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("PutResourcePolicy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ResourcePolicy"=>ResourcePolicy, "SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    put_secret_value(secret_id)
    put_secret_value(secret_id, params::Dict{String,<:Any})

Stores a new encrypted secret value in the specified secret. To do this, the operation
creates a new version and attaches it to the secret. The version can contain a new
SecretString value or a new SecretBinary value. You can also specify the staging labels
that are initially attached to the new version.  The Secrets Manager console uses only the
SecretString field. To add binary data to a secret with the SecretBinary field you must use
the AWS CLI or one of the AWS SDKs.    If this operation creates the first version for the
secret then Secrets Manager automatically attaches the staging label AWSCURRENT to the new
version.   If you do not specify a value for VersionStages then Secrets Manager
automatically moves the staging label AWSCURRENT to this new version.   If this operation
moves the staging label AWSCURRENT from another version to this version, then Secrets
Manager also automatically moves the staging label AWSPREVIOUS to the version that
AWSCURRENT was removed from.   This operation is idempotent. If a version with a VersionId
with the same value as the ClientRequestToken parameter already exists and you specify the
same secret data, the operation succeeds but does nothing. However, if the secret data is
different, then the operation fails because you cannot modify an existing version; you can
only create new ones.      If you call an operation to encrypt or decrypt the SecretString
or SecretBinary for a secret in the same account as the calling user and that secret
doesn't specify a AWS KMS encryption key, Secrets Manager uses the account's default AWS
managed customer master key (CMK) with the alias aws/secretsmanager. If this key doesn't
already exist in your account then Secrets Manager creates it for you automatically. All
users and roles in the same AWS account automatically have access to use the default CMK.
Note that if an Secrets Manager API call results in AWS creating the account's AWS-managed
CMK, it can result in a one-time significant delay in returning the result.   If the secret
resides in a different AWS account from the credentials calling an API that requires
encryption or decryption of the secret value then you must create and use a custom AWS KMS
CMK because you can't access the default CMK for the account using credentials from a
different AWS account. Store the ARN of the CMK in the secret when you create the secret or
when you update it by including it in the KMSKeyId. If you call an API that must encrypt or
decrypt SecretString or SecretBinary using credentials from a different account then the
AWS KMS key policy must grant cross-account access to that other account's user or role for
both the kms:GenerateDataKey and kms:Decrypt operations.     Minimum permissions  To run
this command, you must have the following permissions:   secretsmanager:PutSecretValue
kms:GenerateDataKey - needed only if you use a customer-managed AWS KMS key to encrypt the
secret. You do not need this permission to use the account's default AWS managed CMK for
Secrets Manager.    Related operations    To retrieve the encrypted value you store in the
version of a secret, use GetSecretValue.   To create a secret, use CreateSecret.   To get
the details for a secret, use DescribeSecret.   To list the versions attached to a secret,
use ListSecretVersionIds.

# Arguments
- `secret_id`: Specifies the secret to which you want to add a new version. You can specify
  either the Amazon Resource Name (ARN) or the friendly name of the secret. The secret must
  already exist.  If you specify an ARN, we generally recommend that you specify a complete
  ARN. You can specify a partial ARN too—for example, if you don’t include the final
  hyphen and six random characters that Secrets Manager adds at the end of the ARN when you
  created the secret. A partial ARN match can work as long as it uniquely matches only one
  secret. However, if your secret has a name that ends in a hyphen followed by six characters
  (before Secrets Manager adds the hyphen and six characters to the ARN) and you try to use
  that as a partial ARN, then those characters cause Secrets Manager to assume that you’re
  specifying a complete ARN. This confusion can cause unexpected results. To avoid this
  situation, we recommend that you don’t create secret names ending with a hyphen followed
  by six characters. If you specify an incomplete ARN without the random suffix, and instead
  provide the 'friendly name', you must not include the random suffix. If you do include the
  random suffix added by Secrets Manager, you receive either a ResourceNotFoundException or
  an AccessDeniedException error, depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: (Optional) Specifies a unique identifier for the new version of
  the secret.   If you use the AWS CLI or one of the AWS SDK to call this operation, then you
  can leave this parameter empty. The CLI or SDK generates a random UUID for you and includes
  that in the request. If you don't use the SDK and instead generate a raw HTTP request to
  the Secrets Manager service endpoint, then you must generate a ClientRequestToken yourself
  for new versions and include that value in the request.   This value helps ensure
  idempotency. Secrets Manager uses this value to prevent the accidental creation of
  duplicate versions if there are failures and retries during the Lambda rotation function's
  processing. We recommend that you generate a UUID-type value to ensure uniqueness within
  the specified secret.    If the ClientRequestToken value isn't already associated with a
  version of the secret then a new version of the secret is created.    If a version with
  this value already exists and that version's SecretString or SecretBinary values are the
  same as those in the request then the request is ignored (the operation is idempotent).
  If a version with this value already exists and the version of the SecretString and
  SecretBinary values are different from those in the request then the request fails because
  you cannot modify an existing secret version. You can only create new versions to store new
  secret values.   This value becomes the VersionId of the new version.
- `"SecretBinary"`: (Optional) Specifies binary data that you want to encrypt and store in
  the new version of the secret. To use this parameter in the command-line tools, we
  recommend that you store your binary data in a file and then use the appropriate technique
  for your tool to pass the contents of the file as a parameter. Either SecretBinary or
  SecretString must have a value, but not both. They cannot both be empty. This parameter is
  not accessible if the secret using the Secrets Manager console.
- `"SecretString"`: (Optional) Specifies text data that you want to encrypt and store in
  this new version of the secret. Either SecretString or SecretBinary must have a value, but
  not both. They cannot both be empty. If you create this secret by using the Secrets Manager
  console then Secrets Manager puts the protected secret text in only the SecretString
  parameter. The Secrets Manager console stores the information as a JSON structure of
  key/value pairs that the default Lambda rotation function knows how to parse. For storing
  multiple values, we recommend that you use a JSON text string argument and specify
  key/value pairs. For information on how to format a JSON parameter for the various command
  line tool environments, see Using JSON for Parameters in the AWS CLI User Guide.  For
  example:  [{\"username\":\"bob\"},{\"password\":\"abc123xyz456\"}]  If your command-line
  tool or SDK requires quotation marks around the parameter, you should use single quotes to
  avoid confusion with the double quotes required in the JSON text.
- `"VersionStages"`: (Optional) Specifies a list of staging labels that are attached to
  this version of the secret. These staging labels are used to track the versions through the
  rotation process by the Lambda rotation function. A staging label must be unique to a
  single version of the secret. If you specify a staging label that's already associated with
  a different version of the same secret then that staging label is automatically removed
  from the other version and attached to this version. If you do not specify a value for
  VersionStages then Secrets Manager automatically moves the staging label AWSCURRENT to this
  new version.
"""
put_secret_value(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("PutSecretValue", Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())); aws_config=aws_config)
put_secret_value(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("PutSecretValue", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())), params)); aws_config=aws_config)

"""
    remove_regions_from_replication(remove_replica_regions, secret_id)
    remove_regions_from_replication(remove_replica_regions, secret_id, params::Dict{String,<:Any})

Remove regions from replication.

# Arguments
- `remove_replica_regions`: Remove replication from specific Regions.
- `secret_id`: Remove a secret by SecretId from replica Regions.

"""
remove_regions_from_replication(RemoveReplicaRegions, SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RemoveRegionsFromReplication", Dict{String, Any}("RemoveReplicaRegions"=>RemoveReplicaRegions, "SecretId"=>SecretId); aws_config=aws_config)
remove_regions_from_replication(RemoveReplicaRegions, SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RemoveRegionsFromReplication", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("RemoveReplicaRegions"=>RemoveReplicaRegions, "SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    replicate_secret_to_regions(add_replica_regions, secret_id)
    replicate_secret_to_regions(add_replica_regions, secret_id, params::Dict{String,<:Any})

Converts an existing secret to a multi-Region secret and begins replication the secret to a
list of new regions.

# Arguments
- `add_replica_regions`: Add Regions to replicate the secret.
- `secret_id`: Use the Secret Id to replicate a secret to regions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ForceOverwriteReplicaSecret"`: (Optional) If set, Secrets Manager replication
  overwrites a secret with the same name in the destination region.
"""
replicate_secret_to_regions(AddReplicaRegions, SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ReplicateSecretToRegions", Dict{String, Any}("AddReplicaRegions"=>AddReplicaRegions, "SecretId"=>SecretId); aws_config=aws_config)
replicate_secret_to_regions(AddReplicaRegions, SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ReplicateSecretToRegions", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("AddReplicaRegions"=>AddReplicaRegions, "SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    restore_secret(secret_id)
    restore_secret(secret_id, params::Dict{String,<:Any})

Cancels the scheduled deletion of a secret by removing the DeletedDate time stamp. This
makes the secret accessible to query once again.  Minimum permissions  To run this command,
you must have the following permissions:   secretsmanager:RestoreSecret    Related
operations    To delete a secret, use DeleteSecret.

# Arguments
- `secret_id`: Specifies the secret that you want to restore from a previously scheduled
  deletion. You can specify either the Amazon Resource Name (ARN) or the friendly name of the
  secret.  If you specify an ARN, we generally recommend that you specify a complete ARN. You
  can specify a partial ARN too—for example, if you don’t include the final hyphen and
  six random characters that Secrets Manager adds at the end of the ARN when you created the
  secret. A partial ARN match can work as long as it uniquely matches only one secret.
  However, if your secret has a name that ends in a hyphen followed by six characters (before
  Secrets Manager adds the hyphen and six characters to the ARN) and you try to use that as a
  partial ARN, then those characters cause Secrets Manager to assume that you’re specifying
  a complete ARN. This confusion can cause unexpected results. To avoid this situation, we
  recommend that you don’t create secret names ending with a hyphen followed by six
  characters. If you specify an incomplete ARN without the random suffix, and instead provide
  the 'friendly name', you must not include the random suffix. If you do include the random
  suffix added by Secrets Manager, you receive either a ResourceNotFoundException or an
  AccessDeniedException error, depending on your permissions.

"""
restore_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RestoreSecret", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
restore_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RestoreSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    rotate_secret(secret_id)
    rotate_secret(secret_id, params::Dict{String,<:Any})

Configures and starts the asynchronous process of rotating this secret. If you include the
configuration parameters, the operation sets those values for the secret and then
immediately starts a rotation. If you do not include the configuration parameters, the
operation starts a rotation with the values already stored in the secret. After the
rotation completes, the protected service and its clients all use the new version of the
secret.  This required configuration information includes the ARN of an AWS Lambda function
and the time between scheduled rotations. The Lambda rotation function creates a new
version of the secret and creates or updates the credentials on the protected service to
match. After testing the new credentials, the function marks the new secret with the
staging label AWSCURRENT so that your clients all immediately begin to use the new version.
For more information about rotating secrets and how to configure a Lambda function to
rotate the secrets for your protected service, see Rotating Secrets in AWS Secrets Manager
in the AWS Secrets Manager User Guide. Secrets Manager schedules the next rotation when the
previous one completes. Secrets Manager schedules the date by adding the rotation interval
(number of days) to the actual date of the last rotation. The service chooses the hour
within that 24-hour date window randomly. The minute is also chosen somewhat randomly, but
weighted towards the top of the hour and influenced by a variety of factors that help
distribute load. The rotation function must end with the versions of the secret in one of
two states:   The AWSPENDING and AWSCURRENT staging labels are attached to the same version
of the secret, or   The AWSPENDING staging label is not attached to any version of the
secret.   If the AWSPENDING staging label is present but not attached to the same version
as AWSCURRENT then any later invocation of RotateSecret assumes that a previous rotation
request is still in progress and returns an error.  Minimum permissions  To run this
command, you must have the following permissions:   secretsmanager:RotateSecret
lambda:InvokeFunction (on the function specified in the secret's metadata)    Related
operations    To list the secrets in your account, use ListSecrets.   To get the details
for a version of a secret, use DescribeSecret.   To create a new version of a secret, use
CreateSecret.   To attach staging labels to or remove staging labels from a version of a
secret, use UpdateSecretVersionStage.

# Arguments
- `secret_id`: Specifies the secret that you want to rotate. You can specify either the
  Amazon Resource Name (ARN) or the friendly name of the secret.  If you specify an ARN, we
  generally recommend that you specify a complete ARN. You can specify a partial ARN
  too—for example, if you don’t include the final hyphen and six random characters that
  Secrets Manager adds at the end of the ARN when you created the secret. A partial ARN match
  can work as long as it uniquely matches only one secret. However, if your secret has a name
  that ends in a hyphen followed by six characters (before Secrets Manager adds the hyphen
  and six characters to the ARN) and you try to use that as a partial ARN, then those
  characters cause Secrets Manager to assume that you’re specifying a complete ARN. This
  confusion can cause unexpected results. To avoid this situation, we recommend that you
  don’t create secret names ending with a hyphen followed by six characters. If you specify
  an incomplete ARN without the random suffix, and instead provide the 'friendly name', you
  must not include the random suffix. If you do include the random suffix added by Secrets
  Manager, you receive either a ResourceNotFoundException or an AccessDeniedException error,
  depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: (Optional) Specifies a unique identifier for the new version of
  the secret that helps ensure idempotency.  If you use the AWS CLI or one of the AWS SDK to
  call this operation, then you can leave this parameter empty. The CLI or SDK generates a
  random UUID for you and includes that in the request for this parameter. If you don't use
  the SDK and instead generate a raw HTTP request to the Secrets Manager service endpoint,
  then you must generate a ClientRequestToken yourself for new versions and include that
  value in the request. You only need to specify your own value if you implement your own
  retry logic and want to ensure that a given secret is not created twice. We recommend that
  you generate a UUID-type value to ensure uniqueness within the specified secret.  Secrets
  Manager uses this value to prevent the accidental creation of duplicate versions if there
  are failures and retries during the function's processing. This value becomes the VersionId
  of the new version.
- `"RotationLambdaARN"`: (Optional) Specifies the ARN of the Lambda function that can
  rotate the secret.
- `"RotationRules"`: A structure that defines the rotation configuration for this secret.
"""
rotate_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RotateSecret", Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())); aws_config=aws_config)
rotate_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("RotateSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())), params)); aws_config=aws_config)

"""
    stop_replication_to_replica(secret_id)
    stop_replication_to_replica(secret_id, params::Dict{String,<:Any})

Removes the secret from replication and promotes the secret to a regional secret in the
replica Region.

# Arguments
- `secret_id`: Response to StopReplicationToReplica of a secret, based on the SecretId.

"""
stop_replication_to_replica(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("StopReplicationToReplica", Dict{String, Any}("SecretId"=>SecretId); aws_config=aws_config)
stop_replication_to_replica(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("StopReplicationToReplica", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId), params)); aws_config=aws_config)

"""
    tag_resource(secret_id, tags)
    tag_resource(secret_id, tags, params::Dict{String,<:Any})

Attaches one or more tags, each consisting of a key name and a value, to the specified
secret. Tags are part of the secret's overall metadata, and are not associated with any
specific version of the secret. This operation only appends tags to the existing list of
tags. To remove tags, you must use UntagResource. The following basic restrictions apply to
tags:   Maximum number of tags per secret—50   Maximum key length—127 Unicode
characters in UTF-8   Maximum value length—255 Unicode characters in UTF-8   Tag keys and
values are case sensitive.   Do not use the aws: prefix in your tag names or values because
AWS reserves it for AWS use. You can't edit or delete tag names or values with this prefix.
Tags with this prefix do not count against your tags per secret limit.   If you use your
tagging schema across multiple services and resources, remember other services might have
restrictions on allowed characters. Generally allowed characters: letters, spaces, and
numbers representable in UTF-8, plus the following special characters: + - = . _ : / @.
If you use tags as part of your security strategy, then adding or removing a tag can change
permissions. If successfully completing this operation would result in you losing your
permissions for this secret, then the operation is blocked and returns an Access Denied
error.   Minimum permissions  To run this command, you must have the following permissions:
  secretsmanager:TagResource    Related operations    To remove one or more tags from the
collection attached to a secret, use UntagResource.   To view the list of tags attached to
a secret, use DescribeSecret.

# Arguments
- `secret_id`: The identifier for the secret that you want to attach tags to. You can
  specify either the Amazon Resource Name (ARN) or the friendly name of the secret.  If you
  specify an ARN, we generally recommend that you specify a complete ARN. You can specify a
  partial ARN too—for example, if you don’t include the final hyphen and six random
  characters that Secrets Manager adds at the end of the ARN when you created the secret. A
  partial ARN match can work as long as it uniquely matches only one secret. However, if your
  secret has a name that ends in a hyphen followed by six characters (before Secrets Manager
  adds the hyphen and six characters to the ARN) and you try to use that as a partial ARN,
  then those characters cause Secrets Manager to assume that you’re specifying a complete
  ARN. This confusion can cause unexpected results. To avoid this situation, we recommend
  that you don’t create secret names ending with a hyphen followed by six characters. If
  you specify an incomplete ARN without the random suffix, and instead provide the 'friendly
  name', you must not include the random suffix. If you do include the random suffix added by
  Secrets Manager, you receive either a ResourceNotFoundException or an AccessDeniedException
  error, depending on your permissions.
- `tags`: The tags to attach to the secret. Each element in the list consists of a Key and
  a Value. This parameter to the API requires a JSON text string argument. For information on
  how to format a JSON parameter for the various command line tool environments, see Using
  JSON for Parameters in the AWS CLI User Guide. For the AWS CLI, you can also use the
  syntax: --Tags Key=\"Key1\",Value=\"Value1\" Key=\"Key2\",Value=\"Value2\"[,…]

"""
tag_resource(SecretId, Tags; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("TagResource", Dict{String, Any}("SecretId"=>SecretId, "Tags"=>Tags); aws_config=aws_config)
tag_resource(SecretId, Tags, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("TagResource", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "Tags"=>Tags), params)); aws_config=aws_config)

"""
    untag_resource(secret_id, tag_keys)
    untag_resource(secret_id, tag_keys, params::Dict{String,<:Any})

Removes one or more tags from the specified secret. This operation is idempotent. If a
requested tag is not attached to the secret, no error is returned and the secret metadata
is unchanged.  If you use tags as part of your security strategy, then removing a tag can
change permissions. If successfully completing this operation would result in you losing
your permissions for this secret, then the operation is blocked and returns an Access
Denied error.   Minimum permissions  To run this command, you must have the following
permissions:   secretsmanager:UntagResource    Related operations    To add one or more
tags to the collection attached to a secret, use TagResource.   To view the list of tags
attached to a secret, use DescribeSecret.

# Arguments
- `secret_id`: The identifier for the secret that you want to remove tags from. You can
  specify either the Amazon Resource Name (ARN) or the friendly name of the secret.  If you
  specify an ARN, we generally recommend that you specify a complete ARN. You can specify a
  partial ARN too—for example, if you don’t include the final hyphen and six random
  characters that Secrets Manager adds at the end of the ARN when you created the secret. A
  partial ARN match can work as long as it uniquely matches only one secret. However, if your
  secret has a name that ends in a hyphen followed by six characters (before Secrets Manager
  adds the hyphen and six characters to the ARN) and you try to use that as a partial ARN,
  then those characters cause Secrets Manager to assume that you’re specifying a complete
  ARN. This confusion can cause unexpected results. To avoid this situation, we recommend
  that you don’t create secret names ending with a hyphen followed by six characters. If
  you specify an incomplete ARN without the random suffix, and instead provide the 'friendly
  name', you must not include the random suffix. If you do include the random suffix added by
  Secrets Manager, you receive either a ResourceNotFoundException or an AccessDeniedException
  error, depending on your permissions.
- `tag_keys`: A list of tag key names to remove from the secret. You don't specify the
  value. Both the key and its associated value are removed. This parameter to the API
  requires a JSON text string argument. For information on how to format a JSON parameter for
  the various command line tool environments, see Using JSON for Parameters in the AWS CLI
  User Guide.

"""
untag_resource(SecretId, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UntagResource", Dict{String, Any}("SecretId"=>SecretId, "TagKeys"=>TagKeys); aws_config=aws_config)
untag_resource(SecretId, TagKeys, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UntagResource", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "TagKeys"=>TagKeys), params)); aws_config=aws_config)

"""
    update_secret(secret_id)
    update_secret(secret_id, params::Dict{String,<:Any})

Modifies many of the details of the specified secret. If you include a ClientRequestToken
and either SecretString or SecretBinary then it also creates a new version attached to the
secret. To modify the rotation configuration of a secret, use RotateSecret instead.  The
Secrets Manager console uses only the SecretString parameter and therefore limits you to
encrypting and storing only a text string. To encrypt and store binary data as part of the
version of a secret, you must use either the AWS CLI or one of the AWS SDKs.    If a
version with a VersionId with the same value as the ClientRequestToken parameter already
exists, the operation results in an error. You cannot modify an existing version, you can
only create a new version.   If you include SecretString or SecretBinary to create a new
secret version, Secrets Manager automatically attaches the staging label AWSCURRENT to the
new version.       If you call an operation to encrypt or decrypt the SecretString or
SecretBinary for a secret in the same account as the calling user and that secret doesn't
specify a AWS KMS encryption key, Secrets Manager uses the account's default AWS managed
customer master key (CMK) with the alias aws/secretsmanager. If this key doesn't already
exist in your account then Secrets Manager creates it for you automatically. All users and
roles in the same AWS account automatically have access to use the default CMK. Note that
if an Secrets Manager API call results in AWS creating the account's AWS-managed CMK, it
can result in a one-time significant delay in returning the result.   If the secret resides
in a different AWS account from the credentials calling an API that requires encryption or
decryption of the secret value then you must create and use a custom AWS KMS CMK because
you can't access the default CMK for the account using credentials from a different AWS
account. Store the ARN of the CMK in the secret when you create the secret or when you
update it by including it in the KMSKeyId. If you call an API that must encrypt or decrypt
SecretString or SecretBinary using credentials from a different account then the AWS KMS
key policy must grant cross-account access to that other account's user or role for both
the kms:GenerateDataKey and kms:Decrypt operations.     Minimum permissions  To run this
command, you must have the following permissions:   secretsmanager:UpdateSecret
kms:GenerateDataKey - needed only if you use a custom AWS KMS key to encrypt the secret.
You do not need this permission to use the account's AWS managed CMK for Secrets Manager.
kms:Decrypt - needed only if you use a custom AWS KMS key to encrypt the secret. You do not
need this permission to use the account's AWS managed CMK for Secrets Manager.    Related
operations    To create a new secret, use CreateSecret.   To add only a new version to an
existing secret, use PutSecretValue.   To get the details for a secret, use DescribeSecret.
  To list the versions contained in a secret, use ListSecretVersionIds.

# Arguments
- `secret_id`: Specifies the secret that you want to modify or to which you want to add a
  new version. You can specify either the Amazon Resource Name (ARN) or the friendly name of
  the secret.  If you specify an ARN, we generally recommend that you specify a complete ARN.
  You can specify a partial ARN too—for example, if you don’t include the final hyphen
  and six random characters that Secrets Manager adds at the end of the ARN when you created
  the secret. A partial ARN match can work as long as it uniquely matches only one secret.
  However, if your secret has a name that ends in a hyphen followed by six characters (before
  Secrets Manager adds the hyphen and six characters to the ARN) and you try to use that as a
  partial ARN, then those characters cause Secrets Manager to assume that you’re specifying
  a complete ARN. This confusion can cause unexpected results. To avoid this situation, we
  recommend that you don’t create secret names ending with a hyphen followed by six
  characters. If you specify an incomplete ARN without the random suffix, and instead provide
  the 'friendly name', you must not include the random suffix. If you do include the random
  suffix added by Secrets Manager, you receive either a ResourceNotFoundException or an
  AccessDeniedException error, depending on your permissions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ClientRequestToken"`: (Optional) If you want to add a new version to the secret, this
  parameter specifies a unique identifier for the new version that helps ensure idempotency.
  If you use the AWS CLI or one of the AWS SDK to call this operation, then you can leave
  this parameter empty. The CLI or SDK generates a random UUID for you and includes that in
  the request. If you don't use the SDK and instead generate a raw HTTP request to the
  Secrets Manager service endpoint, then you must generate a ClientRequestToken yourself for
  new versions and include that value in the request. You typically only need to interact
  with this value if you implement your own retry logic and want to ensure that a given
  secret is not created twice. We recommend that you generate a UUID-type value to ensure
  uniqueness within the specified secret.  Secrets Manager uses this value to prevent the
  accidental creation of duplicate versions if there are failures and retries during the
  Lambda rotation function's processing.   If the ClientRequestToken value isn't already
  associated with a version of the secret then a new version of the secret is created.    If
  a version with this value already exists and that version's SecretString and SecretBinary
  values are the same as those in the request then the request is ignored (the operation is
  idempotent).    If a version with this value already exists and that version's SecretString
  and SecretBinary values are different from the request then an error occurs because you
  cannot modify an existing secret value.   This value becomes the VersionId of the new
  version.
- `"Description"`: (Optional) Specifies an updated user-provided description of the secret.
- `"KmsKeyId"`: (Optional) Specifies an updated ARN or alias of the AWS KMS customer master
  key (CMK) to be used to encrypt the protected text in new versions of this secret.  You can
  only use the account's default CMK to encrypt and decrypt if you call this operation using
  credentials from the same account that owns the secret. If the secret is in a different
  account, then you must create a custom CMK and provide the ARN of that CMK in this field.
  The user making the call must have permissions to both the secret and the CMK in their
  respective accounts.
- `"SecretBinary"`: (Optional) Specifies updated binary data that you want to encrypt and
  store in the new version of the secret. To use this parameter in the command-line tools, we
  recommend that you store your binary data in a file and then use the appropriate technique
  for your tool to pass the contents of the file as a parameter. Either SecretBinary or
  SecretString must have a value, but not both. They cannot both be empty. This parameter is
  not accessible using the Secrets Manager console.
- `"SecretString"`: (Optional) Specifies updated text data that you want to encrypt and
  store in this new version of the secret. Either SecretBinary or SecretString must have a
  value, but not both. They cannot both be empty. If you create this secret by using the
  Secrets Manager console then Secrets Manager puts the protected secret text in only the
  SecretString parameter. The Secrets Manager console stores the information as a JSON
  structure of key/value pairs that the default Lambda rotation function knows how to parse.
  For storing multiple values, we recommend that you use a JSON text string argument and
  specify key/value pairs. For information on how to format a JSON parameter for the various
  command line tool environments, see Using JSON for Parameters in the AWS CLI User Guide.
  For example:  [{\"username\":\"bob\"},{\"password\":\"abc123xyz456\"}]  If your
  command-line tool or SDK requires quotation marks around the parameter, you should use
  single quotes to avoid confusion with the double quotes required in the JSON text. You can
  also 'escape' the double quote character in the embedded JSON text by prefacing each with a
  backslash. For example, the following string is surrounded by double-quotes. All of the
  embedded double quotes are escaped:
  \"[{\"username\":\"bob\"},{\"password\":\"abc123xyz456\"}]\"
"""
update_secret(SecretId; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UpdateSecret", Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())); aws_config=aws_config)
update_secret(SecretId, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UpdateSecret", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "ClientRequestToken"=>string(uuid4())), params)); aws_config=aws_config)

"""
    update_secret_version_stage(secret_id, version_stage)
    update_secret_version_stage(secret_id, version_stage, params::Dict{String,<:Any})

Modifies the staging labels attached to a version of a secret. Staging labels are used to
track a version as it progresses through the secret rotation process. You can attach a
staging label to only one version of a secret at a time. If a staging label to be added is
already attached to another version, then it is moved--removed from the other version first
and then attached to this one. For more information about staging labels, see Staging
Labels in the AWS Secrets Manager User Guide.  The staging labels that you specify in the
VersionStage parameter are added to the existing list of staging labels--they don't replace
it. You can move the AWSCURRENT staging label to this version by including it in this call.
 Whenever you move AWSCURRENT, Secrets Manager automatically moves the label AWSPREVIOUS to
the version that AWSCURRENT was removed from.  If this action results in the last label
being removed from a version, then the version is considered to be 'deprecated' and can be
deleted by Secrets Manager.  Minimum permissions  To run this command, you must have the
following permissions:   secretsmanager:UpdateSecretVersionStage    Related operations
To get the list of staging labels that are currently associated with a version of a secret,
use  DescribeSecret  and examine the SecretVersionsToStages response value.

# Arguments
- `secret_id`: Specifies the secret with the version with the list of staging labels you
  want to modify. You can specify either the Amazon Resource Name (ARN) or the friendly name
  of the secret.  If you specify an ARN, we generally recommend that you specify a complete
  ARN. You can specify a partial ARN too—for example, if you don’t include the final
  hyphen and six random characters that Secrets Manager adds at the end of the ARN when you
  created the secret. A partial ARN match can work as long as it uniquely matches only one
  secret. However, if your secret has a name that ends in a hyphen followed by six characters
  (before Secrets Manager adds the hyphen and six characters to the ARN) and you try to use
  that as a partial ARN, then those characters cause Secrets Manager to assume that you’re
  specifying a complete ARN. This confusion can cause unexpected results. To avoid this
  situation, we recommend that you don’t create secret names ending with a hyphen followed
  by six characters. If you specify an incomplete ARN without the random suffix, and instead
  provide the 'friendly name', you must not include the random suffix. If you do include the
  random suffix added by Secrets Manager, you receive either a ResourceNotFoundException or
  an AccessDeniedException error, depending on your permissions.
- `version_stage`: The staging label to add to this version.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MoveToVersionId"`: (Optional) The secret version ID that you want to add the staging
  label. If you want to remove a label from a version, then do not specify this parameter. If
  the staging label is already attached to a different version of the secret, then you must
  also specify the RemoveFromVersionId parameter.
- `"RemoveFromVersionId"`: Specifies the secret version ID of the version that the staging
  label is to be removed from. If the staging label you are trying to attach to one version
  is already attached to a different version, then you must include this parameter and
  specify the version that the label is to be removed from. If the label is attached and you
  either do not specify this parameter, or the version ID does not match, then the operation
  fails.
"""
update_secret_version_stage(SecretId, VersionStage; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UpdateSecretVersionStage", Dict{String, Any}("SecretId"=>SecretId, "VersionStage"=>VersionStage); aws_config=aws_config)
update_secret_version_stage(SecretId, VersionStage, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("UpdateSecretVersionStage", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("SecretId"=>SecretId, "VersionStage"=>VersionStage), params)); aws_config=aws_config)

"""
    validate_resource_policy(resource_policy)
    validate_resource_policy(resource_policy, params::Dict{String,<:Any})

Validates that the resource policy does not grant a wide range of IAM principals access to
your secret. The JSON request string input and response output displays formatted code with
white space and line breaks for better readability. Submit your input as a single line JSON
string. A resource-based policy is optional for secrets. The API performs three checks when
validating the secret:   Sends a call to Zelkova, an automated reasoning engine, to ensure
your Resource Policy does not allow broad access to your secret.   Checks for correct
syntax in a policy.   Verifies the policy does not lock out a caller.    Minimum
Permissions  You must have the permissions required to access the following APIs:
secretsmanager:PutResourcePolicy     secretsmanager:ValidateResourcePolicy

# Arguments
- `resource_policy`: A JSON-formatted string constructed according to the grammar and
  syntax for an AWS resource-based policy. The policy in the string identifies who can access
  or manage this secret and its versions. For information on how to format a JSON parameter
  for the various command line tool environments, see Using JSON for Parameters in the AWS
  CLI User Guide.publi

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"SecretId"`:  (Optional) The identifier of the secret with the resource-based policy you
  want to validate. You can specify either the Amazon Resource Name (ARN) or the friendly
  name of the secret.  If you specify an ARN, we generally recommend that you specify a
  complete ARN. You can specify a partial ARN too—for example, if you don’t include the
  final hyphen and six random characters that Secrets Manager adds at the end of the ARN when
  you created the secret. A partial ARN match can work as long as it uniquely matches only
  one secret. However, if your secret has a name that ends in a hyphen followed by six
  characters (before Secrets Manager adds the hyphen and six characters to the ARN) and you
  try to use that as a partial ARN, then those characters cause Secrets Manager to assume
  that you’re specifying a complete ARN. This confusion can cause unexpected results. To
  avoid this situation, we recommend that you don’t create secret names ending with a
  hyphen followed by six characters. If you specify an incomplete ARN without the random
  suffix, and instead provide the 'friendly name', you must not include the random suffix. If
  you do include the random suffix added by Secrets Manager, you receive either a
  ResourceNotFoundException or an AccessDeniedException error, depending on your permissions.
"""
validate_resource_policy(ResourcePolicy; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ValidateResourcePolicy", Dict{String, Any}("ResourcePolicy"=>ResourcePolicy); aws_config=aws_config)
validate_resource_policy(ResourcePolicy, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()) = secrets_manager("ValidateResourcePolicy", Dict{String, Any}(mergewith(_merge, Dict{String, Any}("ResourcePolicy"=>ResourcePolicy), params)); aws_config=aws_config)


text:
"""
find_best_assignment(C, maximize=false) = solution

Solve the two-dimensional assignment problem with a rectangular cost matrix C,
scanning row-wise.

Note that cost returned can overflow if using smaller integer types

# Example
```julia
julia> M=rand(1:100,3,4)
3×4 Matrix{Int64}:
 77  51  42  67
 72  53  47   4
 24  50  77  96

 julia> sol = find_best_assignment(M)
 AssignmentSolution(CartesianIndex.(1:3, [3, 4, 1]), 70)

 julia> sum(M[sol])
 70

 julia> max_sol = find_best_assignment(M', true)
 AssignmentSolution(CartesianIndex.([1, 2, 4], 1:3), 226)
```

This code is a port of Matlab code released [1] in the public domain by the
US Naval Research Laboratory.

This work is not affliated with or endorsed by the US Naval Research Laboratory.

The algorithm is described in detail in [2].

REFERENCES:
[1] D. F. Crouse, "The Tracker Component Library: Free Routines for Rapid
   Prototyping," IEEE Aerospace and Electronic Systems Magazine, vol. 32,
   no. 5, pp. 18-27, May. 2017
[2] D. F. Crouse, "Advances in displaying uncertain estimates of multiple
   targets," in Proceedings of SPIE: Signal Processing, Sensor Fusion, and
   Target Recognition XXII, vol. 8745, Baltimore, MD, Apr. 2013
"""
function find_best_assignment(cost_matrix::AbstractMatrix{T}, maximize::Bool=false) where T

    numRow, numCol = size(cost_matrix)
	gain = nothing

    numCol > numRow && return find_best_assignment(cost_matrix', maximize)'

	# The cost matrix must have all non-negative elements for the assignment
	# algorithm to work. This forces all of the elements to be positive. The
	# delta is added back in when computing the gain in the end.
    if maximize
        CDelta = maximum(cost_matrix)
        C = CDelta .- cost_matrix
    else
        CDelta = minimum(cost_matrix)
        C = cost_matrix .- CDelta
    end

    # These store the assignment as it is made.
    col4row=zeros(Int, numRow)
    row4col=zeros(Int, numCol)
    S = _dual_eltype(T)
    u=zeros(S, numCol) # The dual variable for the columns
    v=zeros(S, numRow) # The dual variable for the rows.

	pred = zeros(Int, numRow)
	ScannedCols = falses(numCol)
	ScannedRow = falses(numRow)
	Row2Scan = zeros(Int, numRow)
	# Need to be able to fill with infinity
	shortestPathCost = fill(typemax(float(T)), numRow)

	# Initially, none of the columns are assigned.
    for curUnassCol = 1:numCol
        # This finds the shortest augmenting path starting at k and returns
        # the last node in the path.
        sink, pred, u, v = ShortestPath!(
			curUnassCol,u,v,C,col4row,row4col,
			pred,ScannedCols,ScannedRow,Row2Scan,shortestPathCost
		)

        # If the problem is infeasible, mark it as such and return.
		sink == 0 && return AssignmentSolution{T, S}(row4col, col4row, nothing, v, u, true)

        # We have to remove node k from those that must be assigned.
        j = sink
        @inbounds while true
            i = col4row[j] = pred[j]
            j, row4col[i] = row4col[i], j

            if i == curUnassCol
				break
			end
        end
    end

	gain = T(0)
	@inbounds for curCol=1:numCol
		gain += cost_matrix[row4col[curCol],curCol]
	end
	return AssignmentSolution{T, S}(col4row, row4col, gain, u, v)
end

_dual_eltype(T) = T <: Integer ? signed(promote_type(T, Int32)) : T

function ShortestPath!(
		curUnassCol::Int,
		u::AbstractVector{S},
		v::AbstractVector{S},
		C::AbstractMatrix{T},
		col4row::AbstractVector{<:Integer},
		row4col::AbstractVector{<:Integer},
		pred::AbstractVector{<:Integer} = zeros(Int, size(C, 1)),
		ScannedCols::AbstractVector{<:Bool} = falses(size(C,2)),
		ScannedRow::AbstractVector{<:Bool} = falses(size(C,2)),
		Row2Scan::AbstractVector{<:Integer} = Vector(1:size(C, 1)),
    	shortestPathCost::AbstractVector = fill(Inf, size(C, 1))
	) where {T, S}
    # This assumes that unassigned columns go from 1:numUnassigned
    numRow, numCol = size(C)

	pred .= 0
    # Initially, none of the rows and columns have been scanned.
    # This will store a 1 in every column that has been scanned.
	ScannedCols .= false
    # This will store a 1 in every row that has been scanned.
	ScannedRow .= false
	Row2Scan .= 1:numRow # Columns left to scan.
    numRow2Scan = numRow

    sink=0
    delta=T(0)
	closestRowScan = -1
    curCol=curUnassCol
    shortestPathCost .= Inf

    while sink==0
        # Mark the current row as having been visited.
        ScannedCols[curCol] = 1

        # Scan all of the columns that have not already been scanned.
        minVal = Inf
        @inbounds for curRowScan=1:numRow2Scan
            curRow=Row2Scan[curRowScan]
            reducedCost = delta + C[curRow,curCol] - u[curCol] - v[curRow];
            if reducedCost < shortestPathCost[curRow]
                pred[curRow] = curCol;
                shortestPathCost[curRow]=reducedCost;
            end

            #Find the minimum unassigned column that was
            #scanned.
            if shortestPathCost[curRow]<minVal
                minVal=shortestPathCost[curRow];
                closestRowScan=curRowScan;
            end
        end

	   #If the minimum cost column is not finite, then the problem is
	   #not feasible.
        isfinite(minVal) || return 0, pred, u, v

        closestRow = Row2Scan[closestRowScan]
        #Add the column to the list of scanned columns and delete it from
        #the list of columns to scan.
        ScannedRow[closestRow] = 1;
        numRow2Scan -= 1;
		@inbounds for i in closestRowScan:numRow2Scan
			Row2Scan[i] = Row2Scan[i + 1]
		end

        delta=shortestPathCost[closestRow];
        #If we have reached an unassigned row.
        if col4row[closestRow]==0
            sink=closestRow;
        else
            curCol=col4row[closestRow];
        end
    end

    #Dual Update Step

    #Update the first row in the augmenting path.
    u[curUnassCol] += delta

    #Update the rest of the rows in the agumenting path.
	@inbounds for (i, col) in enumerate(ScannedCols)
		if col != 0 && i != curUnassCol
			u[i] += delta - convert(T, shortestPathCost[row4col[i]])
		end
	end

    # Update the scanned columns in the augmenting path.
	@inbounds for (i, row) in enumerate(ScannedRow)
		if row != 0
			v[i] -= delta - convert(T, shortestPathCost[i])
		end
	end

	return sink, pred, u, v
end

ext: jl


text:
export PolarForm, bounds, powerflow
export State, Control, Parameters, NumberOfState, NumberOfControl

"""
    AbstractFormulation

Second layer of the package, implementing the interface between
the first layer (the topology of the network) and the
third layer (implementing the callbacks for the optimization solver).

"""
abstract type AbstractFormulation end

"""
    AbstractFormAttribute

Attributes attached to an `AbstractFormulation`.
"""
abstract type AbstractFormAttribute end

"Number of states attached to a particular formulation."
struct NumberOfState <: AbstractFormAttribute end

"Number of controls attached to a particular formulation."
struct NumberOfControl <: AbstractFormAttribute end

"""
    AbstractVariable

Variables corresponding to a particular formulation.
"""
abstract type AbstractVariable end

"""
    State <: AbstractVariable

All variables `x` depending on the variables `Control` `u` through
a non-linear equation `g(x, u) = 0`.

"""
struct State <: AbstractVariable end

"""
    Control <: AbstractVariable

Implement the independent variables used in the reduced-space
formulation.

"""
struct Control <: AbstractVariable end

"""
    Parameters <: AbstractVariable

Constant parameters.

"""
struct Parameters <: AbstractVariable end

"""
    PhysicalState <: AbstractVariable

All physical variables describing the current physical state
of the underlying network.

`PhysicalState` variables are encoded in a `AbstractNetworkBuffer`,
storing all the physical values needed to describe the current
state of the network.

"""
struct PhysicalState <: AbstractVariable end

# Templates
"""
    get(form::AbstractFormulation, attr::AbstractFormAttribute)

Return value of attribute `attr` attached to the particular
formulation `form`.

## Examples

```julia
get(form, NumberOfState())
get(form, NumberOfControl())

```
"""
function get end

"""
    bounds(form::AbstractFormulation, var::AbstractVariable)

Return the bounds attached to the variable `var`.

    bounds(form::AbstractFormulation, func::Function)

Return a tuple of vectors `(lb, ub)` specifying the admissible range
of the constraints specified by the function `cons_func`.

## Examples

```julia
u_min, u_max = bounds(form, Control())
h_min, h_max = bounds(form, power_constraints)

```
"""
function bounds end

"""
    initial(form::AbstractFormulation, var::AbstractVariable)

Return an initial position for the variable `var`.

## Examples

```julia
u₀ = initial(form, Control())
x₀ = initial(form, State())

```
"""
function initial end

"""
    powerflow(form::AbstractFormulation,
              jacobian::AutoDiff.StateJacobian,
              buffer::AbstractNetworkBuffer;
              kwargs...) where VT <: AbstractVector

Solve the power flow equations `g(x, u) = 0` w.r.t. the state `x`,
using a Newton-Raphson algorithm.
The powerflow equations are specified in the formulation `form`.
The current state `x` and control `u` are specified in
`buffer`. The object `buffer` is modified inplace.

The algorithm stops when a tolerance `tol` or a maximum number of
irations `maxiter` are reached.

## Arguments

* `form::AbstractFormulation`: formulation of the power flow equation
* `jacobian::AutoDiff.StateJacobian`: Jacobian
* `buffer::AbstractNetworkBuffer`: buffer storing current state `x` and control `u`

## Optional arguments

* `linear_solver::AbstractLinearSolver` (default `DirectSolver()`): solver to solve the linear systems `J x = y` arising at each iteration of the Newton-Raphson algorithm.
* `tol::Float64` (default `1e-7`): tolerance of the Newton-Raphson algorithm.
* `maxiter::Int` (default `20`): maximum number of iterations.
* `verbose_level::Int` (default `O`, max value: `3`): verbose level.

"""
function powerflow end

"""
    power_balance!(form::AbstractFormulation, x::VT, u::VT, p::VT) where {VT<:AbstractVector}

Get power balance at buses, depending on the state `x` and the control `u`.

"""
function power_balance! end

# Cost function
"""
    cost_production(form::AbstractFormulation, pg::AbstractVector)::Float64

Get operational cost corresponding to the active power generation
specified in the vector `pg`.

"""
function cost_production end

# Generic constraints
"""
    size_constraint(cons_func::Function)::Bool
Return whether the function `cons_func` is a supported constraint
in the powerflow model.
"""
function is_constraint end

"""
    size_constraint(form::AbstractFormulation, cons_func::Function)::Int

Get number of constraints specified by the function `cons_func`
in the formulation `form`.
"""
function size_constraint end

"""
    state_constraints(form::AbstractFormulation, cons::AbstractVector, buffer::AbstractNetworkBuffer)

Evaluate the constraints porting on the state `x`, as a
function of `x` and `u`. The result is stored inplace, inside `g`.
"""
function state_constraints end

"""
    power_constraints(form::AbstractFormulation, cons::AbstractVector, buffer::AbstractNetworkBuffer) where {VT<:AbstractVector}

Evaluate the constraints on the **power production** that are not taken into
account in

* the box constraints on the control `u`
* the box constraints on the state `x` (implemented in `state_constraints`)

The result is stored inplace, inside `g`.
"""
function power_constraints end

"""
    thermal_limit_constraints(form::AbstractFormulation, cons::AbstractVector, buffer::AbstractNetworkBuffer) where {VT<:AbstractVector}

Evaluate the thermal limit constraints porting on the lines of the network.

The result is stored inplace, inside the vector `g`.
"""
function thermal_limit_constraints end

include("caches.jl")
# Polar formulation
include("polar/polar.jl")


text:
using Documenter, FinEtools, FinEtoolsMeshing

makedocs(
	modules = [FinEtoolsMeshing],
	doctest = false, clean = true,
	format = Documenter.HTML(prettyurls = false),
	authors = "Petr Krysl",
	sitename = "FinEtoolsMeshing.jl",
	pages = Any[
		"Home" => "index.md",
		"How to guide" => "guide/guide.md",
		"Types and Functions" => Any[
			"man/types.md",
			"man/functions.md"]
			]
	)

deploydocs(
    repo = "github.com/PetrKryslUCSD/FinEtoolsMeshing.jl.git",
)