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

"""
    create_call_analytics_category(category_name, rules)
    create_call_analytics_category(category_name, rules, params::Dict{String,<:Any})

Creates an analytics category. Amazon Transcribe applies the conditions specified by your
analytics categories to your call analytics jobs. For each analytics category, you specify
one or more rules. For example, you can specify a rule that the customer sentiment was
neutral or negative within that category. If you start a call analytics job, Amazon
Transcribe applies the category to the analytics job that you've specified.

# Arguments
- `category_name`: The name that you choose for your category when you create it.
- `rules`: To create a category, you must specify between 1 and 20 rules. For each rule,
  you specify a filter to be applied to the attributes of the call. For example, you can
  specify a sentiment filter to detect if the customer's sentiment was negative or neutral.

"""
function create_call_analytics_category(
    CategoryName, Rules; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "CreateCallAnalyticsCategory",
        Dict{String,Any}("CategoryName" => CategoryName, "Rules" => Rules);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_call_analytics_category(
    CategoryName,
    Rules,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateCallAnalyticsCategory",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("CategoryName" => CategoryName, "Rules" => Rules),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_language_model(base_model_name, input_data_config, language_code, model_name)
    create_language_model(base_model_name, input_data_config, language_code, model_name, params::Dict{String,<:Any})

Creates a new custom language model. Use Amazon S3 prefixes to provide the location of your
input files. The time it takes to create your model depends on the size of your training
data.

# Arguments
- `base_model_name`: The Amazon Transcribe standard language model, or base model used to
  create your custom language model. If you want to use your custom language model to
  transcribe audio with a sample rate of 16,000 Hz or greater, choose Wideband. If you want
  to use your custom language model to transcribe audio with a sample rate that is less than
  16,000 Hz, choose Narrowband.
- `input_data_config`: Contains the data access role and the Amazon S3 prefixes to read the
  required input files to create a custom language model.
- `language_code`: The language of the input text you're using to train your custom
  language model.
- `model_name`: The name you choose for your custom language model when you create it.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: Adds one or more tags, each in the form of a key:value pair, to a new language
  model at the time you create this new model.
"""
function create_language_model(
    BaseModelName,
    InputDataConfig,
    LanguageCode,
    ModelName;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateLanguageModel",
        Dict{String,Any}(
            "BaseModelName" => BaseModelName,
            "InputDataConfig" => InputDataConfig,
            "LanguageCode" => LanguageCode,
            "ModelName" => ModelName,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_language_model(
    BaseModelName,
    InputDataConfig,
    LanguageCode,
    ModelName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateLanguageModel",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "BaseModelName" => BaseModelName,
                    "InputDataConfig" => InputDataConfig,
                    "LanguageCode" => LanguageCode,
                    "ModelName" => ModelName,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_medical_vocabulary(language_code, vocabulary_file_uri, vocabulary_name)
    create_medical_vocabulary(language_code, vocabulary_file_uri, vocabulary_name, params::Dict{String,<:Any})

Creates a new custom vocabulary that you can use to modify how Amazon Transcribe Medical
transcribes your audio file.

# Arguments
- `language_code`: The language code for the language used for the entries in your custom
  vocabulary. The language code of your custom vocabulary must match the language code of
  your transcription job. US English (en-US) is the only language code available for Amazon
  Transcribe Medical.
- `vocabulary_file_uri`: The location in Amazon S3 of the text file you use to define your
  custom vocabulary. The URI must be in the same Amazon Web Services Region as the resource
  that you're calling. Enter information about your VocabularyFileUri in the following
  format:
  https://s3.&lt;aws-region&gt;.amazonaws.com/&lt;bucket-name&gt;/&lt;keyprefix&gt;/&lt;object
  key&gt;   The following is an example URI for a vocabulary file that is stored in Amazon
  S3:  https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt  For more
  information about Amazon S3 object names, see Object Keys in the Amazon S3 Developer Guide.
  For more information about custom vocabularies, see Medical Custom Vocabularies.
- `vocabulary_name`: The name of the custom vocabulary. This case-sensitive name must be
  unique within an Amazon Web Services account. If you try to create a vocabulary with the
  same name as a previous vocabulary, you get a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: Adds one or more tags, each in the form of a key:value pair, to a new medical
  vocabulary at the time you create this new vocabulary.
"""
function create_medical_vocabulary(
    LanguageCode,
    VocabularyFileUri,
    VocabularyName;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateMedicalVocabulary",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode,
            "VocabularyFileUri" => VocabularyFileUri,
            "VocabularyName" => VocabularyName,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_medical_vocabulary(
    LanguageCode,
    VocabularyFileUri,
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateMedicalVocabulary",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode,
                    "VocabularyFileUri" => VocabularyFileUri,
                    "VocabularyName" => VocabularyName,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_vocabulary(language_code, vocabulary_name)
    create_vocabulary(language_code, vocabulary_name, params::Dict{String,<:Any})

Creates a new custom vocabulary that you can use to change the way Amazon Transcribe
handles transcription of an audio file.

# Arguments
- `language_code`: The language code of the vocabulary entries. For a list of languages and
  their corresponding language codes, see transcribe-whatis.
- `vocabulary_name`: The name of the vocabulary. The name must be unique within an Amazon
  Web Services account. The name is case sensitive. If you try to create a vocabulary with
  the same name as a previous vocabulary you will receive a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Phrases"`: An array of strings that contains the vocabulary entries.
- `"Tags"`: Adds one or more tags, each in the form of a key:value pair, to a new Amazon
  Transcribe vocabulary at the time you create this new vocabulary.
- `"VocabularyFileUri"`: The S3 location of the text file that contains the definition of
  the custom vocabulary. The URI must be in the same region as the API endpoint that you are
  calling. The general form is: For more information about S3 object names, see Object Keys
  in the Amazon S3 Developer Guide. For more information about custom vocabularies, see
  Custom vocabularies.
"""
function create_vocabulary(
    LanguageCode, VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "CreateVocabulary",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_vocabulary(
    LanguageCode,
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateVocabulary",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_vocabulary_filter(language_code, vocabulary_filter_name)
    create_vocabulary_filter(language_code, vocabulary_filter_name, params::Dict{String,<:Any})

Creates a new vocabulary filter that you can use to filter words, such as profane words,
from the output of a transcription job.

# Arguments
- `language_code`: The language code of the words in the vocabulary filter. All words in
  the filter must be in the same language. The vocabulary filter can only be used with
  transcription jobs in the specified language.
- `vocabulary_filter_name`: The vocabulary filter name. The name must be unique within the
  account that contains it. If you try to create a vocabulary filter with the same name as
  another vocabulary filter, you get a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Tags"`: Adds one or more tags, each in the form of a key:value pair, to a new Amazon
  Transcribe vocabulary filter at the time you create this new vocabulary filter.
- `"VocabularyFilterFileUri"`: The Amazon S3 location of a text file used as input to
  create the vocabulary filter. Only use characters from the character set defined for custom
  vocabularies. For a list of character sets, see Character Sets for Custom Vocabularies. The
  specified file must be less than 50 KB of UTF-8 characters. If you provide the location of
  a list of words in the VocabularyFilterFileUri parameter, you can't use the Words parameter.
- `"Words"`: The words to use in the vocabulary filter. Only use characters from the
  character set defined for custom vocabularies. For a list of character sets, see Character
  Sets for Custom Vocabularies. If you provide a list of words in the Words parameter, you
  can't use the VocabularyFilterFileUri parameter.
"""
function create_vocabulary_filter(
    LanguageCode, VocabularyFilterName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "CreateVocabularyFilter",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode, "VocabularyFilterName" => VocabularyFilterName
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_vocabulary_filter(
    LanguageCode,
    VocabularyFilterName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "CreateVocabularyFilter",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode,
                    "VocabularyFilterName" => VocabularyFilterName,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a call analytics category using its name.

# Arguments
- `category_name`: The name of the call analytics category that you're choosing to delete.
  The value is case sensitive.

"""
function delete_call_analytics_category(
    CategoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteCallAnalyticsCategory",
        Dict{String,Any}("CategoryName" => CategoryName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_call_analytics_category(
    CategoryName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteCallAnalyticsCategory",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("CategoryName" => CategoryName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a call analytics job using its name.

# Arguments
- `call_analytics_job_name`: The name of the call analytics job you want to delete.

"""
function delete_call_analytics_job(
    CallAnalyticsJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteCallAnalyticsJob",
        Dict{String,Any}("CallAnalyticsJobName" => CallAnalyticsJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_call_analytics_job(
    CallAnalyticsJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteCallAnalyticsJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("CallAnalyticsJobName" => CallAnalyticsJobName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a custom language model using its name.

# Arguments
- `model_name`: The name of the model you're choosing to delete.

"""
function delete_language_model(ModelName; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "DeleteLanguageModel",
        Dict{String,Any}("ModelName" => ModelName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_language_model(
    ModelName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteLanguageModel",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("ModelName" => ModelName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a transcription job generated by Amazon Transcribe Medical and any related
information.

# Arguments
- `medical_transcription_job_name`: The name you provide to the
  DeleteMedicalTranscriptionJob object to delete a transcription job.

"""
function delete_medical_transcription_job(
    MedicalTranscriptionJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteMedicalTranscriptionJob",
        Dict{String,Any}("MedicalTranscriptionJobName" => MedicalTranscriptionJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_medical_transcription_job(
    MedicalTranscriptionJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteMedicalTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "MedicalTranscriptionJobName" => MedicalTranscriptionJobName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a vocabulary from Amazon Transcribe Medical.

# Arguments
- `vocabulary_name`: The name of the vocabulary that you want to delete.

"""
function delete_medical_vocabulary(
    VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteMedicalVocabulary",
        Dict{String,Any}("VocabularyName" => VocabularyName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_medical_vocabulary(
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteMedicalVocabulary",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("VocabularyName" => VocabularyName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a previously submitted transcription job along with any other generated results
such as the transcription, models, and so on.

# Arguments
- `transcription_job_name`: The name of the transcription job to be deleted.

"""
function delete_transcription_job(
    TranscriptionJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteTranscriptionJob",
        Dict{String,Any}("TranscriptionJobName" => TranscriptionJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_transcription_job(
    TranscriptionJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("TranscriptionJobName" => TranscriptionJobName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Deletes a vocabulary from Amazon Transcribe.

# Arguments
- `vocabulary_name`: The name of the vocabulary to delete.

"""
function delete_vocabulary(
    VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteVocabulary",
        Dict{String,Any}("VocabularyName" => VocabularyName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_vocabulary(
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteVocabulary",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("VocabularyName" => VocabularyName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Removes a vocabulary filter.

# Arguments
- `vocabulary_filter_name`: The name of the vocabulary filter to remove.

"""
function delete_vocabulary_filter(
    VocabularyFilterName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DeleteVocabularyFilter",
        Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_vocabulary_filter(
    VocabularyFilterName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DeleteVocabularyFilter",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Gets information about a single custom language model. Use this information to see details
about the language model in your Amazon Web Services account. You can also see whether the
base language model used to create your custom language model has been updated. If Amazon
Transcribe has updated the base model, you can create a new custom language model using the
updated base model. If the language model wasn't created, you can use this operation to
understand why Amazon Transcribe couldn't create it.

# Arguments
- `model_name`: The name of the custom language model you submit to get more information.

"""
function describe_language_model(
    ModelName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "DescribeLanguageModel",
        Dict{String,Any}("ModelName" => ModelName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_language_model(
    ModelName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "DescribeLanguageModel",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("ModelName" => ModelName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Retrieves information about a call analytics category.

# Arguments
- `category_name`: The name of the category you want information about. This value is case
  sensitive.

"""
function get_call_analytics_category(
    CategoryName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetCallAnalyticsCategory",
        Dict{String,Any}("CategoryName" => CategoryName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_call_analytics_category(
    CategoryName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetCallAnalyticsCategory",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("CategoryName" => CategoryName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns information about a call analytics job. To see the status of the job, check the
CallAnalyticsJobStatus field. If the status is COMPLETED, the job is finished and you can
find the results at the location specified in the TranscriptFileUri field. If you enable
personally identifiable information (PII) redaction, the redacted transcript appears in the
RedactedTranscriptFileUri field.

# Arguments
- `call_analytics_job_name`: The name of the analytics job you want information about. This
  value is case sensitive.

"""
function get_call_analytics_job(
    CallAnalyticsJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetCallAnalyticsJob",
        Dict{String,Any}("CallAnalyticsJobName" => CallAnalyticsJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_call_analytics_job(
    CallAnalyticsJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetCallAnalyticsJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("CallAnalyticsJobName" => CallAnalyticsJobName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns information about a transcription job from Amazon Transcribe Medical. To see the
status of the job, check the TranscriptionJobStatus field. If the status is COMPLETED, the
job is finished. You find the results of the completed job in the TranscriptFileUri field.

# Arguments
- `medical_transcription_job_name`: The name of the medical transcription job.

"""
function get_medical_transcription_job(
    MedicalTranscriptionJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetMedicalTranscriptionJob",
        Dict{String,Any}("MedicalTranscriptionJobName" => MedicalTranscriptionJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_medical_transcription_job(
    MedicalTranscriptionJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetMedicalTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "MedicalTranscriptionJobName" => MedicalTranscriptionJobName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Retrieves information about a medical vocabulary.

# Arguments
- `vocabulary_name`: The name of the vocabulary that you want information about. The value
  is case sensitive.

"""
function get_medical_vocabulary(
    VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetMedicalVocabulary",
        Dict{String,Any}("VocabularyName" => VocabularyName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_medical_vocabulary(
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetMedicalVocabulary",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("VocabularyName" => VocabularyName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns information about a transcription job. To see the status of the job, check the
TranscriptionJobStatus field. If the status is COMPLETED, the job is finished and you can
find the results at the location specified in the TranscriptFileUri field. If you enable
content redaction, the redacted transcript appears in RedactedTranscriptFileUri.

# Arguments
- `transcription_job_name`: The name of the job.

"""
function get_transcription_job(
    TranscriptionJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetTranscriptionJob",
        Dict{String,Any}("TranscriptionJobName" => TranscriptionJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_transcription_job(
    TranscriptionJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("TranscriptionJobName" => TranscriptionJobName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Gets information about a vocabulary.

# Arguments
- `vocabulary_name`: The name of the vocabulary to return information about. The name is
  case sensitive.

"""
function get_vocabulary(VocabularyName; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "GetVocabulary",
        Dict{String,Any}("VocabularyName" => VocabularyName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_vocabulary(
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetVocabulary",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("VocabularyName" => VocabularyName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns information about a vocabulary filter.

# Arguments
- `vocabulary_filter_name`: The name of the vocabulary filter for which to return
  information.

"""
function get_vocabulary_filter(
    VocabularyFilterName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "GetVocabularyFilter",
        Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_vocabulary_filter(
    VocabularyFilterName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "GetVocabularyFilter",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Provides more information about the call analytics categories that you've created. You can
use the information in this list to find a specific category. You can then use the
operation to get more information about it.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of categories to return in each page of results. If
  there are fewer results than the value you specify, only the actual results are returned.
  If you do not specify a value, the default of 5 is used.
- `"NextToken"`: When included, NextTokenfetches the next set of categories if the result
  of the previous request was truncated.
"""
function list_call_analytics_categories(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListCallAnalyticsCategories";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_call_analytics_categories(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListCallAnalyticsCategories",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

List call analytics jobs with a specified status or substring that matches their names.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"JobNameContains"`: When specified, the jobs returned in the list are limited to jobs
  whose name contains the specified string.
- `"MaxResults"`:  The maximum number of call analytics jobs to return in each page of
  results. If there are fewer results than the value you specify, only the actual results are
  returned. If you do not specify a value, the default of 5 is used.
- `"NextToken"`: If you receive a truncated result in the previous request of , include
  NextToken to fetch the next set of jobs.
- `"Status"`: When specified, returns only call analytics jobs with the specified status.
  Jobs are ordered by creation date, with the most recent jobs returned first. If you don't
  specify a status, Amazon Transcribe returns all analytics jobs ordered by creation date.
"""
function list_call_analytics_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListCallAnalyticsJobs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_call_analytics_jobs(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListCallAnalyticsJobs",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Provides more information about the custom language models you've created. You can use the
information in this list to find a specific custom language model. You can then use the
operation to get more information about it.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`:  The maximum number of language models to return in each page of results.
  If there are fewer results than the value you specify, only the actual results are
  returned. If you do not specify a value, the default of 5 is used.
- `"NameContains"`: When specified, the custom language model names returned contain the
  substring you've specified.
- `"NextToken"`: When included, fetches the next set of jobs if the result of the previous
  request was truncated.
- `"StatusEquals"`: When specified, returns only custom language models with the specified
  status. Language models are ordered by creation date, with the newest models first. If you
  don't specify a status, Amazon Transcribe returns all custom language models ordered by
  date.
"""
function list_language_models(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListLanguageModels"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_language_models(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListLanguageModels", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end

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

Lists medical transcription jobs with a specified status or substring that matches their
names.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"JobNameContains"`: When specified, the jobs returned in the list are limited to jobs
  whose name contains the specified string.
- `"MaxResults"`:  The maximum number of medical transcription jobs to return in each page
  of results. If there are fewer results than the value you specify, only the actual results
  are returned. If you do not specify a value, the default of 5 is used.
- `"NextToken"`: If you a receive a truncated result in the previous request of
  ListMedicalTranscriptionJobs, include NextToken to fetch the next set of jobs.
- `"Status"`: When specified, returns only medical transcription jobs with the specified
  status. Jobs are ordered by creation date, with the newest jobs returned first. If you
  don't specify a status, Amazon Transcribe Medical returns all transcription jobs ordered by
  creation date.
"""
function list_medical_transcription_jobs(;
    aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListMedicalTranscriptionJobs";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_medical_transcription_jobs(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListMedicalTranscriptionJobs",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns a list of vocabularies that match the specified criteria. If you don't enter a
value in any of the request parameters, returns the entire list of vocabularies.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of vocabularies to return in each page of results. If
  there are fewer results than the value you specify, only the actual results are returned.
  If you do not specify a value, the default of 5 is used.
- `"NameContains"`: Returns vocabularies whose names contain the specified string. The
  search is not case sensitive. ListMedicalVocabularies returns both \"vocabularyname\" and
  \"VocabularyName\".
- `"NextToken"`: If the result of your previous request to ListMedicalVocabularies was
  truncated, include the NextToken to fetch the next set of vocabularies.
- `"StateEquals"`: When specified, returns only vocabularies with the VocabularyState equal
  to the specified vocabulary state. Use this field to see which vocabularies are ready for
  your medical transcription jobs.
"""
function list_medical_vocabularies(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListMedicalVocabularies"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_medical_vocabularies(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListMedicalVocabularies",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Lists all tags associated with a given transcription job, vocabulary, or resource.

# Arguments
- `resource_arn`: Lists all tags associated with a given Amazon Resource Name (ARN).

"""
function list_tags_for_resource(
    ResourceArn; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListTagsForResource",
        Dict{String,Any}("ResourceArn" => ResourceArn);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_tags_for_resource(
    ResourceArn,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "ListTagsForResource",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("ResourceArn" => ResourceArn), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Lists transcription jobs with the specified status.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"JobNameContains"`: When specified, the jobs returned in the list are limited to jobs
  whose name contains the specified string.
- `"MaxResults"`: The maximum number of jobs to return in each page of results. If there
  are fewer results than the value you specify, only the actual results are returned. If you
  do not specify a value, the default of 5 is used.
- `"NextToken"`: If the result of the previous request to ListTranscriptionJobs is
  truncated, include the NextToken to fetch the next set of jobs.
- `"Status"`: When specified, returns only transcription jobs with the specified status.
  Jobs are ordered by creation date, with the newest jobs returned first. If you don’t
  specify a status, Amazon Transcribe returns all transcription jobs ordered by creation date.
"""
function list_transcription_jobs(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListTranscriptionJobs"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_transcription_jobs(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListTranscriptionJobs",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Returns a list of vocabularies that match the specified criteria. If no criteria are
specified, returns the entire list of vocabularies.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of vocabularies to return in each page of results. If
  there are fewer results than the value you specify, only the actual results are returned.
  If you do not specify a value, the default of 5 is used.
- `"NameContains"`: When specified, the vocabularies returned in the list are limited to
  vocabularies whose name contains the specified string. The search is not case sensitive,
  ListVocabularies returns both \"vocabularyname\" and \"VocabularyName\" in the response
  list.
- `"NextToken"`: If the result of the previous request to ListVocabularies was truncated,
  include the NextToken to fetch the next set of jobs.
- `"StateEquals"`: When specified, only returns vocabularies with the VocabularyState field
  equal to the specified state.
"""
function list_vocabularies(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListVocabularies"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_vocabularies(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListVocabularies", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end

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

Gets information about vocabulary filters.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: The maximum number of filters to return in each page of results. If there
  are fewer results than the value you specify, only the actual results are returned. If you
  do not specify a value, the default of 5 is used.
- `"NameContains"`: Filters the response so that it only contains vocabulary filters whose
  name contains the specified string.
- `"NextToken"`: If the result of the previous request to ListVocabularyFilters was
  truncated, include the NextToken to fetch the next set of collections.
"""
function list_vocabulary_filters(; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "ListVocabularyFilters"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_vocabulary_filters(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "ListVocabularyFilters",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    start_call_analytics_job(call_analytics_job_name, data_access_role_arn, media)
    start_call_analytics_job(call_analytics_job_name, data_access_role_arn, media, params::Dict{String,<:Any})

Starts an asynchronous analytics job that not only transcribes the audio recording of a
caller and agent, but also returns additional insights. These insights include how quickly
or loudly the caller or agent was speaking. To retrieve additional insights with your
analytics jobs, create categories. A category is a way to classify analytics jobs based on
attributes, such as a customer's sentiment or a particular phrase being used during the
call. For more information, see the operation.

# Arguments
- `call_analytics_job_name`: The name of the call analytics job. You can't use the string
  \".\" or \"..\" by themselves as the job name. The name must also be unique within an
  Amazon Web Services account. If you try to create a call analytics job with the same name
  as a previous call analytics job, you get a ConflictException error.
- `data_access_role_arn`: The Amazon Resource Name (ARN) of a role that has access to the
  S3 bucket that contains your input files. Amazon Transcribe assumes this role to read
  queued audio files. If you have specified an output S3 bucket for your transcription
  results, this role should have access to the output bucket as well.
- `media`:

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ChannelDefinitions"`: When you start a call analytics job, you must pass an array that
  maps the agent and the customer to specific audio channels. The values you can assign to a
  channel are 0 and 1. The agent and the customer must each have their own channel. You can't
  assign more than one channel to an agent or customer.
- `"OutputEncryptionKMSKeyId"`: The Amazon Resource Name (ARN) of the Amazon Web Services
  Key Management Service key used to encrypt the output of the call analytics job. The user
  calling the operation must have permission to use the specified KMS key. You use either of
  the following to identify an Amazon Web Services KMS key in the current account:   KMS Key
  ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"   KMS Key Alias: \"alias/ExampleAlias\"    You
  can use either of the following to identify a KMS key in the current account or another
  account:   Amazon Resource Name (ARN) of a KMS key in the current account or another
  account: \"arn:aws:kms:region:account ID:key/1234abcd-12ab-34cd-56ef1234567890ab\"   ARN of
  a KMS Key Alias: \"arn:aws:kms:region:account ID:alias/ExampleAlias\"   If you don't
  specify an encryption key, the output of the call analytics job is encrypted with the
  default Amazon S3 key (SSE-S3). If you specify a KMS key to encrypt your output, you must
  also specify an output location in the OutputLocation parameter.
- `"OutputLocation"`: The Amazon S3 location where the output of the call analytics job is
  stored. You can provide the following location types to store the output of call analytics
  job:   s3://DOC-EXAMPLE-BUCKET1  If you specify a bucket, Amazon Transcribe saves the
  output of the analytics job as a JSON file at the root level of the bucket.
  s3://DOC-EXAMPLE-BUCKET1/folder/ f you specify a path, Amazon Transcribe saves the output
  of the analytics job as s3://DOC-EXAMPLE-BUCKET1/folder/your-transcription-job-name.json If
  you specify a folder, you must provide a trailing slash.
  s3://DOC-EXAMPLE-BUCKET1/folder/filename.json  If you provide a path that has the filename
  specified, Amazon Transcribe saves the output of the analytics job as
  s3://DOC-EXAMPLEBUCKET1/folder/filename.json   You can specify an Amazon Web Services Key
  Management Service (KMS) key to encrypt the output of our analytics job using the
  OutputEncryptionKMSKeyId parameter. If you don't specify a KMS key, Amazon Transcribe uses
  the default Amazon S3 key for server-side encryption of the analytics job output that is
  placed in your S3 bucket.
- `"Settings"`: A Settings object that provides optional settings for a call analytics job.
"""
function start_call_analytics_job(
    CallAnalyticsJobName,
    DataAccessRoleArn,
    Media;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "StartCallAnalyticsJob",
        Dict{String,Any}(
            "CallAnalyticsJobName" => CallAnalyticsJobName,
            "DataAccessRoleArn" => DataAccessRoleArn,
            "Media" => Media,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function start_call_analytics_job(
    CallAnalyticsJobName,
    DataAccessRoleArn,
    Media,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "StartCallAnalyticsJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "CallAnalyticsJobName" => CallAnalyticsJobName,
                    "DataAccessRoleArn" => DataAccessRoleArn,
                    "Media" => Media,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    start_medical_transcription_job(language_code, media, medical_transcription_job_name, output_bucket_name, specialty, type)
    start_medical_transcription_job(language_code, media, medical_transcription_job_name, output_bucket_name, specialty, type, params::Dict{String,<:Any})

Starts a batch job to transcribe medical speech to text.

# Arguments
- `language_code`: The language code for the language spoken in the input media file. US
  English (en-US) is the valid value for medical transcription jobs. Any other value you
  enter for language code results in a BadRequestException error.
- `media`:
- `medical_transcription_job_name`: The name of the medical transcription job. You can't
  use the strings \".\" or \"..\" by themselves as the job name. The name must also be unique
  within an Amazon Web Services account. If you try to create a medical transcription job
  with the same name as a previous medical transcription job, you get a ConflictException
  error.
- `output_bucket_name`: The Amazon S3 location where the transcription is stored. You must
  set OutputBucketName for Amazon Transcribe Medical to store the transcription results. Your
  transcript appears in the S3 location you specify. When you call the
  GetMedicalTranscriptionJob, the operation returns this location in the TranscriptFileUri
  field. The S3 bucket must have permissions that allow Amazon Transcribe Medical to put
  files in the bucket. For more information, see Permissions Required for IAM User Roles. You
  can specify an Amazon Web Services Key Management Service (KMS) key to encrypt the output
  of your transcription using the OutputEncryptionKMSKeyId parameter. If you don't specify a
  KMS key, Amazon Transcribe Medical uses the default Amazon S3 key for server-side
  encryption of transcripts that are placed in your S3 bucket.
- `specialty`: The medical specialty of any clinician speaking in the input media.
- `type`: The type of speech in the input audio. CONVERSATION refers to conversations
  between two or more speakers, e.g., a conversations between doctors and patients. DICTATION
  refers to single-speaker dictated speech, such as clinical notes.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ContentIdentificationType"`: You can configure Amazon Transcribe Medical to label
  content in the transcription output. If you specify PHI, Amazon Transcribe Medical labels
  the personal health information (PHI) that it identifies in the transcription output.
- `"KMSEncryptionContext"`: A map of plain text, non-secret key:value pairs, known as
  encryption context pairs, that provide an added layer of security for your data.
- `"MediaFormat"`: The audio format of the input media file.
- `"MediaSampleRateHertz"`: The sample rate, in Hertz, of the audio track in the input
  media file. If you do not specify the media sample rate, Amazon Transcribe Medical
  determines the sample rate. If you specify the sample rate, it must match the rate detected
  by Amazon Transcribe Medical. In most cases, you should leave the MediaSampleRateHertz
  field blank and let Amazon Transcribe Medical determine the sample rate.
- `"OutputEncryptionKMSKeyId"`: The Amazon Resource Name (ARN) of the Amazon Web Services
  Key Management Service (KMS) key used to encrypt the output of the transcription job. The
  user calling the StartMedicalTranscriptionJob operation must have permission to use the
  specified KMS key. You use either of the following to identify a KMS key in the current
  account:   KMS Key ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"   KMS Key Alias:
  \"alias/ExampleAlias\"   You can use either of the following to identify a KMS key in the
  current account or another account:   Amazon Resource Name (ARN) of a KMS key in the
  current account or another account: \"arn:aws:kms:region:account
  ID:key/1234abcd-12ab-34cd-56ef-1234567890ab\"   ARN of a KMS Key Alias:
  \"arn:aws:kms:region:account ID:alias/ExampleAlias\"   If you don't specify an encryption
  key, the output of the medical transcription job is encrypted with the default Amazon S3
  key (SSE-S3). If you specify a KMS key to encrypt your output, you must also specify an
  output location in the OutputBucketName parameter.
- `"OutputKey"`: You can specify a location in an Amazon S3 bucket to store the output of
  your medical transcription job. If you don't specify an output key, Amazon Transcribe
  Medical stores the output of your transcription job in the Amazon S3 bucket you specified.
  By default, the object key is \"your-transcription-job-name.json\". You can use output keys
  to specify the Amazon S3 prefix and file name of the transcription output. For example,
  specifying the Amazon S3 prefix, \"folder1/folder2/\", as an output key would lead to the
  output being stored as \"folder1/folder2/your-transcription-job-name.json\". If you specify
  \"my-other-job-name.json\" as the output key, the object key is changed to
  \"my-other-job-name.json\". You can use an output key to change both the prefix and the
  file name, for example \"folder/my-other-job-name.json\". If you specify an output key, you
  must also specify an S3 bucket in the OutputBucketName parameter.
- `"Settings"`: Optional settings for the medical transcription job.
- `"Tags"`: Add tags to an Amazon Transcribe medical transcription job.
"""
function start_medical_transcription_job(
    LanguageCode,
    Media,
    MedicalTranscriptionJobName,
    OutputBucketName,
    Specialty,
    Type;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "StartMedicalTranscriptionJob",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode,
            "Media" => Media,
            "MedicalTranscriptionJobName" => MedicalTranscriptionJobName,
            "OutputBucketName" => OutputBucketName,
            "Specialty" => Specialty,
            "Type" => Type,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function start_medical_transcription_job(
    LanguageCode,
    Media,
    MedicalTranscriptionJobName,
    OutputBucketName,
    Specialty,
    Type,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "StartMedicalTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode,
                    "Media" => Media,
                    "MedicalTranscriptionJobName" => MedicalTranscriptionJobName,
                    "OutputBucketName" => OutputBucketName,
                    "Specialty" => Specialty,
                    "Type" => Type,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    start_transcription_job(media, transcription_job_name)
    start_transcription_job(media, transcription_job_name, params::Dict{String,<:Any})

Starts an asynchronous job to transcribe speech to text.

# Arguments
- `media`: An object that describes the input media for a transcription job.
- `transcription_job_name`: The name of the job. You can't use the strings \".\" or \"..\"
  by themselves as the job name. The name must also be unique within an Amazon Web Services
  account. If you try to create a transcription job with the same name as a previous
  transcription job, you get a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"ContentRedaction"`: An object that contains the request parameters for content
  redaction.
- `"IdentifyLanguage"`: Set this field to true to enable automatic language identification.
  Automatic language identification is disabled by default. You receive a BadRequestException
  error if you enter a value for a LanguageCode.
- `"JobExecutionSettings"`: Provides information about how a transcription job is executed.
  Use this field to indicate that the job can be queued for deferred execution if the
  concurrency limit is reached and there are no slots available to immediately run the job.
- `"KMSEncryptionContext"`: A map of plain text, non-secret key:value pairs, known as
  encryption context pairs, that provide an added layer of security for your data.
- `"LanguageCode"`: The language code for the language used in the input media file. To
  transcribe speech in Modern Standard Arabic (ar-SA), your audio or video file must be
  encoded at a sample rate of 16,000 Hz or higher.
- `"LanguageOptions"`: An object containing a list of languages that might be present in
  your collection of audio files. Automatic language identification chooses a language that
  best matches the source audio from that list. To transcribe speech in Modern Standard
  Arabic (ar-SA), your audio or video file must be encoded at a sample rate of 16,000 Hz or
  higher.
- `"MediaFormat"`: The format of the input media file.
- `"MediaSampleRateHertz"`: The sample rate, in Hertz, of the audio track in the input
  media file.  If you do not specify the media sample rate, Amazon Transcribe determines the
  sample rate. If you specify the sample rate, it must match the sample rate detected by
  Amazon Transcribe. In most cases, you should leave the MediaSampleRateHertz field blank and
  let Amazon Transcribe determine the sample rate.
- `"ModelSettings"`: Choose the custom language model you use for your transcription job in
  this parameter.
- `"OutputBucketName"`: The location where the transcription is stored. If you set the
  OutputBucketName, Amazon Transcribe puts the transcript in the specified S3 bucket. When
  you call the GetTranscriptionJob operation, the operation returns this location in the
  TranscriptFileUri field. If you enable content redaction, the redacted transcript appears
  in RedactedTranscriptFileUri. If you enable content redaction and choose to output an
  unredacted transcript, that transcript's location still appears in the TranscriptFileUri.
  The S3 bucket must have permissions that allow Amazon Transcribe to put files in the
  bucket. For more information, see Permissions Required for IAM User Roles. You can specify
  an Amazon Web Services Key Management Service (KMS) key to encrypt the output of your
  transcription using the OutputEncryptionKMSKeyId parameter. If you don't specify a KMS key,
  Amazon Transcribe uses the default Amazon S3 key for server-side encryption of transcripts
  that are placed in your S3 bucket. If you don't set the OutputBucketName, Amazon Transcribe
  generates a pre-signed URL, a shareable URL that provides secure access to your
  transcription, and returns it in the TranscriptFileUri field. Use this URL to download the
  transcription.
- `"OutputEncryptionKMSKeyId"`: The Amazon Resource Name (ARN) of the Amazon Web Services
  Key Management Service (KMS) key used to encrypt the output of the transcription job. The
  user calling the StartTranscriptionJob operation must have permission to use the specified
  KMS key. You can use either of the following to identify a KMS key in the current account:
   KMS Key ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"   KMS Key Alias:
  \"alias/ExampleAlias\"   You can use either of the following to identify a KMS key in the
  current account or another account:   Amazon Resource Name (ARN) of a KMS Key:
  \"arn:aws:kms:region:account ID:key/1234abcd-12ab-34cd-56ef-1234567890ab\"   ARN of a KMS
  Key Alias: \"arn:aws:kms:region:account ID:alias/ExampleAlias\"   If you don't specify an
  encryption key, the output of the transcription job is encrypted with the default Amazon S3
  key (SSE-S3). If you specify a KMS key to encrypt your output, you must also specify an
  output location in the OutputBucketName parameter.
- `"OutputKey"`: You can specify a location in an Amazon S3 bucket to store the output of
  your transcription job. If you don't specify an output key, Amazon Transcribe stores the
  output of your transcription job in the Amazon S3 bucket you specified. By default, the
  object key is \"your-transcription-job-name.json\". You can use output keys to specify the
  Amazon S3 prefix and file name of the transcription output. For example, specifying the
  Amazon S3 prefix, \"folder1/folder2/\", as an output key would lead to the output being
  stored as \"folder1/folder2/your-transcription-job-name.json\". If you specify
  \"my-other-job-name.json\" as the output key, the object key is changed to
  \"my-other-job-name.json\". You can use an output key to change both the prefix and the
  file name, for example \"folder/my-other-job-name.json\". If you specify an output key, you
  must also specify an S3 bucket in the OutputBucketName parameter.
- `"Settings"`: A Settings object that provides optional settings for a transcription job.
- `"Subtitles"`: Add subtitles to your batch transcription job.
- `"Tags"`: Add tags to an Amazon Transcribe transcription job.
"""
function start_transcription_job(
    Media, TranscriptionJobName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "StartTranscriptionJob",
        Dict{String,Any}("Media" => Media, "TranscriptionJobName" => TranscriptionJobName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function start_transcription_job(
    Media,
    TranscriptionJobName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "StartTranscriptionJob",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "Media" => Media, "TranscriptionJobName" => TranscriptionJobName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Tags a Amazon Transcribe resource with the given list of tags.

# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the Amazon Transcribe resource you want
  to tag.
- `tags`: The tags you are assigning to a given Amazon Transcribe resource.

"""
function tag_resource(ResourceArn, Tags; aws_config::AbstractAWSConfig=global_aws_config())
    return transcribe(
        "TagResource",
        Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function tag_resource(
    ResourceArn,
    Tags,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "TagResource",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("ResourceArn" => ResourceArn, "Tags" => Tags),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Removes specified tags from a specified Amazon Transcribe resource.

# Arguments
- `resource_arn`: The Amazon Resource Name (ARN) of the Amazon Transcribe resource you want
  to remove tags from.
- `tag_keys`: A list of tag keys you want to remove from a specified Amazon Transcribe
  resource.

"""
function untag_resource(
    ResourceArn, TagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "UntagResource",
        Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function untag_resource(
    ResourceArn,
    TagKeys,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "UntagResource",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("ResourceArn" => ResourceArn, "TagKeys" => TagKeys),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_call_analytics_category(category_name, rules)
    update_call_analytics_category(category_name, rules, params::Dict{String,<:Any})

Updates the call analytics category with new values. The UpdateCallAnalyticsCategory
operation overwrites all of the existing information with the values that you provide in
the request.

# Arguments
- `category_name`: The name of the analytics category to update. The name is case
  sensitive. If you try to update a call analytics category with the same name as a previous
  category you will receive a ConflictException error.
- `rules`: The rules used for the updated analytics category. The rules that you provide in
  this field replace the ones that are currently being used.

"""
function update_call_analytics_category(
    CategoryName, Rules; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "UpdateCallAnalyticsCategory",
        Dict{String,Any}("CategoryName" => CategoryName, "Rules" => Rules);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_call_analytics_category(
    CategoryName,
    Rules,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "UpdateCallAnalyticsCategory",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("CategoryName" => CategoryName, "Rules" => Rules),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_medical_vocabulary(language_code, vocabulary_name)
    update_medical_vocabulary(language_code, vocabulary_name, params::Dict{String,<:Any})

Updates a vocabulary with new values that you provide in a different text file from the one
you used to create the vocabulary. The UpdateMedicalVocabulary operation overwrites all of
the existing information with the values that you provide in the request.

# Arguments
- `language_code`: The language code of the language used for the entries in the updated
  vocabulary. US English (en-US) is the only valid language code in Amazon Transcribe Medical.
- `vocabulary_name`: The name of the vocabulary to update. The name is case sensitive. If
  you try to update a vocabulary with the same name as a vocabulary you've already made, you
  get a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VocabularyFileUri"`: The location in Amazon S3 of the text file that contains your
  custom vocabulary. The URI must be in the same Amazon Web Services Region as the resource
  that you are calling. The following is the format for a URI:
  https://s3.&lt;aws-region&gt;.amazonaws.com/&lt;bucket-name&gt;/&lt;keyprefix&gt;/&lt;object
  key&gt;   For example:  https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt
  For more information about Amazon S3 object names, see Object Keys in the Amazon S3
  Developer Guide. For more information about custom vocabularies in Amazon Transcribe
  Medical, see Medical Custom Vocabularies.
"""
function update_medical_vocabulary(
    LanguageCode, VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "UpdateMedicalVocabulary",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_medical_vocabulary(
    LanguageCode,
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "UpdateMedicalVocabulary",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_vocabulary(language_code, vocabulary_name)
    update_vocabulary(language_code, vocabulary_name, params::Dict{String,<:Any})

Updates an existing vocabulary with new values. The UpdateVocabulary operation overwrites
all of the existing information with the values that you provide in the request.

# Arguments
- `language_code`: The language code of the vocabulary entries. For a list of languages and
  their corresponding language codes, see transcribe-whatis.
- `vocabulary_name`: The name of the vocabulary to update. The name is case sensitive. If
  you try to update a vocabulary with the same name as a previous vocabulary you will receive
  a ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Phrases"`: An array of strings containing the vocabulary entries.
- `"VocabularyFileUri"`: The S3 location of the text file that contains the definition of
  the custom vocabulary. The URI must be in the same region as the API endpoint that you are
  calling. The general form is  For example: For more information about S3 object names, see
  Object Keys in the Amazon S3 Developer Guide. For more information about custom
  vocabularies, see Custom Vocabularies.
"""
function update_vocabulary(
    LanguageCode, VocabularyName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "UpdateVocabulary",
        Dict{String,Any}(
            "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_vocabulary(
    LanguageCode,
    VocabularyName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "UpdateVocabulary",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "LanguageCode" => LanguageCode, "VocabularyName" => VocabularyName
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

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

Updates a vocabulary filter with a new list of filtered words.

# Arguments
- `vocabulary_filter_name`: The name of the vocabulary filter to update. If you try to
  update a vocabulary filter with the same name as another vocabulary filter, you get a
  ConflictException error.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"VocabularyFilterFileUri"`: The Amazon S3 location of a text file used as input to
  create the vocabulary filter. Only use characters from the character set defined for custom
  vocabularies. For a list of character sets, see Character Sets for Custom Vocabularies. The
  specified file must be less than 50 KB of UTF-8 characters. If you provide the location of
  a list of words in the VocabularyFilterFileUri parameter, you can't use the Words parameter.
- `"Words"`: The words to use in the vocabulary filter. Only use characters from the
  character set defined for custom vocabularies. For a list of character sets, see Character
  Sets for Custom Vocabularies. If you provide a list of words in the Words parameter, you
  can't use the VocabularyFilterFileUri parameter.
"""
function update_vocabulary_filter(
    VocabularyFilterName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return transcribe(
        "UpdateVocabularyFilter",
        Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_vocabulary_filter(
    VocabularyFilterName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return transcribe(
        "UpdateVocabularyFilter",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("VocabularyFilterName" => VocabularyFilterName),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
