type BadRequestException struct {
	Message *string
}

type ConflictException struct {
	Message *string
}

type ContentRedaction struct {
	// The output transcript file stored in either the default S3 bucket or in a bucket
	// you specify. When you choose redacted Amazon Transcribe outputs only the
	// redacted transcript. When you choose redacted_and_unredacted Amazon Transcribe
	// outputs both the redacted and unredacted transcripts.
	RedactionOutput RedactionOutput
	// Request parameter that defines the entities to be redacted. The only accepted
	// value is PII.
	RedactionType RedactionType
}

type InternalFailureException struct {
	Message *string
}

type JobExecutionSettings struct {
	// Indicates whether a job should be queued by Amazon Transcribe when the
	// concurrent execution limit is exceeded. When the AllowDeferredExecution field is
	// true, jobs are queued and executed when the number of executing jobs falls below
	// the concurrent execution limit. If the field is false, Amazon Transcribe returns
	// a LimitExceededException exception. If you specify the AllowDeferredExecution
	// field, you must specify the DataAccessRoleArn field.
	AllowDeferredExecution *bool
	// The Amazon Resource Name (ARN) of a role that has access to the S3 bucket that
	// contains the input files. Amazon Transcribe assumes this role to read queued
	// media files. If you have specified an output S3 bucket for the transcription
	// results, this role should have access to the output bucket as well. If you
	// specify the AllowDeferredExecution field, you must specify the DataAccessRoleArn
	// field.
	DataAccessRoleArn *string
}

type LanguageCode string

const (
	LanguageCodeEn_us LanguageCode = "en-US"
	LanguageCodeEs_us LanguageCode = "es-US"
	LanguageCodeEn_au LanguageCode = "en-AU"
	LanguageCodeFr_ca LanguageCode = "fr-CA"
	LanguageCodeEn_gb LanguageCode = "en-GB"
	LanguageCodeDe_de LanguageCode = "de-DE"
	LanguageCodePt_br LanguageCode = "pt-BR"
	LanguageCodeFr_fr LanguageCode = "fr-FR"
	LanguageCodeIt_it LanguageCode = "it-IT"
	LanguageCodeKo_kr LanguageCode = "ko-KR"
	LanguageCodeEs_es LanguageCode = "es-ES"
	LanguageCodeEn_in LanguageCode = "en-IN"
	LanguageCodeHi_in LanguageCode = "hi-IN"
	LanguageCodeAr_sa LanguageCode = "ar-SA"
	LanguageCodeRu_ru LanguageCode = "ru-RU"
	LanguageCodeZh_cn LanguageCode = "zh-CN"
	LanguageCodeNl_nl LanguageCode = "nl-NL"
	LanguageCodeId_id LanguageCode = "id-ID"
	LanguageCodeTa_in LanguageCode = "ta-IN"
	LanguageCodeFa_ir LanguageCode = "fa-IR"
	LanguageCodeEn_ie LanguageCode = "en-IE"
	LanguageCodeEn_ab LanguageCode = "en-AB"
	LanguageCodeEn_wl LanguageCode = "en-WL"
	LanguageCodePt_pt LanguageCode = "pt-PT"
	LanguageCodeTe_in LanguageCode = "te-IN"
	LanguageCodeTr_tr LanguageCode = "tr-TR"
	LanguageCodeDe_ch LanguageCode = "de-CH"
	LanguageCodeHe_il LanguageCode = "he-IL"
	LanguageCodeMs_my LanguageCode = "ms-MY"
	LanguageCodeJa_jp LanguageCode = "ja-JP"
	LanguageCodeAr_ae LanguageCode = "ar-AE"
)

type LimitExceededException struct {
	Message *string
}

type Media struct {
	// The S3 object location of the input media file. The URI must be in the same
	// region as the API endpoint that you are calling. The general form is:  <p>For
	// example:</p> <p>For more information about S3 object names, see <a
	// href="http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#object-keys">Object
	// Keys</a> in the <i>Amazon S3 Developer Guide</i>.</p>
	MediaFileUri *string
}

type MediaFormat string

const (
	MediaFormatMp3  MediaFormat = "mp3"
	MediaFormatMp4  MediaFormat = "mp4"
	MediaFormatWav  MediaFormat = "wav"
	MediaFormatFlac MediaFormat = "flac"
)

type MedicalTranscript struct {
	// The S3 object location of the medical transcript. Use this URI to access the
	// medical transcript. This URI points to the S3 bucket you created to store the
	// medical transcript.
	TranscriptFileUri *string
}

type MedicalTranscriptionJob struct {
	// If the TranscriptionJobStatus field is FAILED, this field contains information
	// about why the job failed. The FailureReason field contains one of the following
	// values:
	//
	//     * Unsupported media format- The media format specified in the
	// MediaFormat field of the request isn't valid. See the description of the
	// MediaFormat field for a list of valid values.
	//
	//     * The media format provided
	// does not match the detected media format- The media format of the audio file
	// doesn't match the format specified in the MediaFormat field in the request.
	// Check the media format of your media file and make sure the two values match.
	//
	//
	// * Invalid sample rate for audio file- The sample rate specified in the
	// MediaSampleRateHertz of the request isn't valid. The sample rate must be between
	// 8000 and 48000 Hertz.
	//
	//     * The sample rate provided does not match the
	// detected sample rate- The sample rate in the audio file doesn't match the sample
	// rate specified in the MediaSampleRateHertz field in the request. Check the
	// sample rate of your media file and make sure that the two values match.
	//
	//     *
	// Invalid file size: file size too large- The size of your audio file is larger
	// than what Amazon Transcribe Medical can process. For more information, see
	// Guidlines and Quotas
	// (https://docs.aws.amazon.com/transcribe/latest/dg/limits-guidelines.html#limits)
	// in the Amazon Transcribe Medical Guide
	//
	//     * Invalid number of channels: number
	// of channels too large- Your audio contains more channels than Amazon Transcribe
	// Medical is configured to process. To request additional channels, see Amazon
	// Transcribe Medical Endpoints and Quotas
	// (https://docs.aws.amazon.com/general/latest/gr/transcribe-medical.html) in the
	// Amazon Web Services General Reference
	FailureReason *string
	// The type of speech in the transcription job. CONVERSATION is generally used for
	// patient-physician dialogues. DICTATION is the setting for physicians speaking
	// their notes after seeing a patient. For more information, see how-it-works-med
	// ()
	Type Type
	// A timestamp that shows when the job was created.
	CreationTime *time.Time
	// The name for a given medical transcription job.
	MedicalTranscriptionJobName *string
	// Describes the input media file in a transcription request.
	Media *Media
	// An object that contains the MedicalTranscript. The MedicalTranscript contains
	// the TranscriptFileUri.
	Transcript *MedicalTranscript
	// The medical specialty of any clinicians providing a dictation or having a
	// conversation. PRIMARYCARE is the only available setting for this object. This
	// specialty enables you to generate transcriptions for the following medical
	// fields:
	//
	//     * Family Medicine
	Specialty Specialty
	// The completion status of a medical transcription job.
	TranscriptionJobStatus TranscriptionJobStatus
	// A timestamp that shows when the job was completed.
	CompletionTime *time.Time
	// Object that contains object.
	Settings *MedicalTranscriptionSetting
	// A timestamp that shows when the job started processing.
	StartTime *time.Time
	// The sample rate, in Hertz, of the source audio containing medical information.
	// If you don't specify the sample rate, Amazon Transcribe Medical determines it
	// for you. If you choose to specify the sample rate, it must match the rate
	// detected by Amazon Transcribe Medical. In most cases, you should leave the
	// MediaSampleHertz blank and let Amazon Transcribe Medical determine the sample
	// rate.
	MediaSampleRateHertz *int32
	// The format of the input media file.
	MediaFormat MediaFormat
	// The language code for the language spoken in the source audio file. US English
	// (en-US) is the only supported language for medical transcriptions. Any other
	// value you enter for language code results in a BadRequestException error.
	LanguageCode LanguageCode
}

type MedicalTranscriptionJobSummary struct {
	// If the TranscriptionJobStatus field is FAILED, a description of the error.
	FailureReason *string
	// Indicates the location of the transcription job's output. The CUSTOMER_BUCKET is
	// the S3 location provided in the OutputBucketName field when the
	OutputLocationType OutputLocationType
	// The speech of the clinician in the input audio.
	Type Type
	// A timestamp that shows when the job was completed.
	CompletionTime *time.Time
	// A timestamp that shows when the job began processing.
	StartTime *time.Time
	// The status of the medical transcription job.
	TranscriptionJobStatus TranscriptionJobStatus
	// The name of a medical transcription job.
	MedicalTranscriptionJobName *string
	// The language of the transcript in the source audio file.
	LanguageCode LanguageCode
	// A timestamp that shows when the medical transcription job was created.
	CreationTime *time.Time
	// The medical specialty of the transcription job. Primary care is the only valid
	// value.
	Specialty Specialty
}

type MedicalTranscriptionSetting struct {
	// Determines whether the transcription job uses speaker recognition to identify
	// different speakers in the input audio. Speaker recongition labels individual
	// speakers in the audio file. If you set the ShowSpeakerLabels field to true, you
	// must also set the maximum number of speaker labels in the MaxSpeakerLabels
	// field. You can't set both ShowSpeakerLabels and ChannelIdentification in the
	// same request. If you set both, your request returns a BadRequestException.
	ShowSpeakerLabels *bool
	// The maximum number of speakers to identify in the input audio. If there are more
	// speakers in the audio than this number, multiple speakers are identified as a
	// single speaker. If you specify the MaxSpeakerLabels field, you must set the
	// ShowSpeakerLabels field to true.
	MaxSpeakerLabels *int32
	// Determines whether alternative transcripts are generated along with the
	// transcript that has the highest confidence. If you set ShowAlternatives field to
	// true, you must also set the maximum number of alternatives to return in the
	// MaxAlternatives field.
	ShowAlternatives *bool
	// The maximum number of alternatives that you tell the service to return. If you
	// specify the MaxAlternatives field, you must set the ShowAlternatives field to
	// true.
	MaxAlternatives *int32
	// The name of the vocabulary to use when processing a medical transcription job.
	VocabularyName *string
	// Instructs Amazon Transcribe Medical to process each audio channel separately and
	// then merge the transcription output of each channel into a single transcription.
	// Amazon Transcribe Medical also produces a transcription of each item detected on
	// an audio channel, including the start time and end time of the item and
	// alternative transcriptions of item. The alternative transcriptions also come
	// with confidence scores provided by Amazon Transcribe Medical. You can't set both
	// ShowSpeakerLabels and ChannelIdentification in the same request. If you set
	// both, your request returns a BadRequestException
	ChannelIdentification *bool
}

type NotFoundException struct {
	Message *string
}

type OutputLocationType string

const (
	OutputLocationTypeCustomer_bucket OutputLocationType = "CUSTOMER_BUCKET"
	OutputLocationTypeService_bucket  OutputLocationType = "SERVICE_BUCKET"
)

type RedactionOutput string

const (
	RedactionOutputRedacted                RedactionOutput = "redacted"
	RedactionOutputRedacted_and_unredacted RedactionOutput = "redacted_and_unredacted"
)

type RedactionType string

const (
	RedactionTypePii RedactionType = "PII"
)

type Settings struct {
	// Instructs Amazon Transcribe to process each audio channel separately and then
	// merge the transcription output of each channel into a single transcription.
	// Amazon Transcribe also produces a transcription of each item detected on an
	// audio channel, including the start time and end time of the item and alternative
	// transcriptions of the item including the confidence that Amazon Transcribe has
	// in the transcription. You can't set both ShowSpeakerLabels and
	// ChannelIdentification in the same request. If you set both, your request returns
	// a BadRequestException.
	ChannelIdentification *bool
	// The name of the vocabulary filter to use when transcribing the audio. The filter
	// that you specify must have the same language code as the transcription job.
	VocabularyFilterName *string
	// The number of alternative transcriptions that the service should return. If you
	// specify the MaxAlternatives field, you must set the ShowAlternatives field to
	// true.
	MaxAlternatives *int32
	// Determines whether the transcription contains alternative transcriptions. If you
	// set the ShowAlternatives field to true, you must also set the maximum number of
	// alternatives to return in the MaxAlternatives field.
	ShowAlternatives *bool
	// Determines whether the transcription job uses speaker recognition to identify
	// different speakers in the input audio. Speaker recognition labels individual
	// speakers in the audio file. If you set the ShowSpeakerLabels field to true, you
	// must also set the maximum number of speaker labels MaxSpeakerLabels field. You
	// can't set both ShowSpeakerLabels and ChannelIdentification in the same request.
	// If you set both, your request returns a BadRequestException.
	ShowSpeakerLabels *bool
	// The maximum number of speakers to identify in the input audio. If there are more
	// speakers in the audio than this number, multiple speakers are identified as a
	// single speaker. If you specify the MaxSpeakerLabels field, you must set the
	// ShowSpeakerLabels field to true.
	MaxSpeakerLabels *int32
	// The name of a vocabulary to use when processing the transcription job.
	VocabularyName *string
	// Set to mask to remove filtered text from the transcript and replace it with
	// three asterisks ("***") as placeholder text. Set to remove to remove filtered
	// text from the transcript without using placeholder text.
	VocabularyFilterMethod VocabularyFilterMethod
}

type Specialty string

const (
	SpecialtyPrimarycare Specialty = "PRIMARYCARE"
)

type Transcript struct {
	// The S3 object location of the the transcript. Use this URI to access the
	// transcript. If you specified an S3 bucket in the OutputBucketName field when you
	// created the job, this is the URI of that bucket. If you chose to store the
	// transcript in Amazon Transcribe, this is a shareable URL that provides secure
	// access to that location.
	TranscriptFileUri *string
	// The S3 object location of the redacted transcript.  <p>Use this URI to access
	// the redacated transcript. If you specified an S3 bucket in the
	// <code>OutputBucketName</code> field when you created the job, this is the URI of
	// that bucket. If you chose to store the transcript in Amazon Transcribe, this is
	// a shareable URL that provides secure access to that location.</p>
	RedactedTranscriptFileUri *string
}

type TranscriptionJob struct {
	// A timestamp that shows when the job was completed.
	CompletionTime *time.Time
	// The status of the transcription job.
	TranscriptionJobStatus TranscriptionJobStatus
	// Optional settings for the transcription job. Use these settings to turn on
	// speaker recognition, to set the maximum number of speakers that should be
	// identified and to specify a custom vocabulary to use when processing the
	// transcription job.
	Settings *Settings
	// The name of the transcription job.
	TranscriptionJobName *string
	// The language code for the input speech.
	LanguageCode LanguageCode
	// The sample rate, in Hertz, of the audio track in the input media file.
	MediaSampleRateHertz *int32
	// A timestamp that shows with the job was started processing.
	StartTime *time.Time
	// The format of the input media file.
	MediaFormat MediaFormat
	// An object that describes the output of the transcription job.
	Transcript *Transcript
	// An object that describes the input media for the transcription job.
	Media *Media
	// A timestamp that shows when the job was created.
	CreationTime *time.Time
	// An object that describes content redaction settings for the transcription job.
	ContentRedaction *ContentRedaction
	// If the TranscriptionJobStatus field is FAILED, this field contains information
	// about why the job failed. The FailureReason field can contain one of the
	// following values:
	//
	//     * Unsupported media format - The media format specified
	// in the MediaFormat field of the request isn't valid. See the description of the
	// MediaFormat field for a list of valid values.
	//
	//     * The media format provided
	// does not match the detected media format - The media format of the audio file
	// doesn't match the format specified in the MediaFormat field in the request.
	// Check the media format of your media file and make sure that the two values
	// match.
	//
	//     * Invalid sample rate for audio file - The sample rate specified in
	// the MediaSampleRateHertz of the request isn't valid. The sample rate must be
	// between 8000 and 48000 Hertz.
	//
	//     * The sample rate provided does not match the
	// detected sample rate - The sample rate in the audio file doesn't match the
	// sample rate specified in the MediaSampleRateHertz field in the request. Check
	// the sample rate of your media file and make sure that the two values match.
	//
	//
	// * Invalid file size: file size too large - The size of your audio file is larger
	// than Amazon Transcribe can process. For more information, see Limits
	// (https://docs.aws.amazon.com/transcribe/latest/dg/limits-guidelines.html#limits)
	// in the Amazon Transcribe Developer Guide.
	//
	//     * Invalid number of channels:
	// number of channels too large - Your audio contains more channels than Amazon
	// Transcribe is configured to process. To request additional channels, see Amazon
	// Transcribe Limits
	// (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits-amazon-transcribe)
	// in the Amazon Web Services General Reference.
	FailureReason *string
	// Provides information about how a transcription job is executed.
	JobExecutionSettings *JobExecutionSettings
}

type TranscriptionJobStatus string

const (
	TranscriptionJobStatusQueued      TranscriptionJobStatus = "QUEUED"
	TranscriptionJobStatusIn_progress TranscriptionJobStatus = "IN_PROGRESS"
	TranscriptionJobStatusFailed      TranscriptionJobStatus = "FAILED"
	TranscriptionJobStatusCompleted   TranscriptionJobStatus = "COMPLETED"
)

type TranscriptionJobSummary struct {
	// A timestamp that shows when the job was created.
	CreationTime *time.Time
	// A timestamp that shows when the job started processing.
	StartTime *time.Time
	// If the TranscriptionJobStatus field is FAILED, a description of the error.
	FailureReason *string
	// The content redaction settings of the transcription job.
	ContentRedaction *ContentRedaction
	// The status of the transcription job. When the status is COMPLETED, use the
	// GetTranscriptionJob operation to get the results of the transcription.
	TranscriptionJobStatus TranscriptionJobStatus
	// The name of the transcription job.
	TranscriptionJobName *string
	// A timestamp that shows when the job was completed.
	CompletionTime *time.Time
	// Indicates the location of the output of the transcription job. If the value is
	// CUSTOMER_BUCKET then the location is the S3 bucket specified in the
	// outputBucketName field when the transcription job was started with the
	// StartTranscriptionJob operation. If the value is SERVICE_BUCKET then the output
	// is stored by Amazon Transcribe and can be retrieved using the URI in the
	// GetTranscriptionJob response's TranscriptFileUri field.
	OutputLocationType OutputLocationType
	// The language code for the input speech.
	LanguageCode LanguageCode
}

type Type string

const (
	TypeConversation Type = "CONVERSATION"
	TypeDictation    Type = "DICTATION"
)

type VocabularyFilterInfo struct {
	// The language code of the words in the vocabulary filter.
	LanguageCode LanguageCode
	// The name of the vocabulary filter. The name must be unique in the account that
	// holds the filter.
	VocabularyFilterName *string
	// The date and time that the vocabulary was last updated.
	LastModifiedTime *time.Time
}

type VocabularyFilterMethod string

const (
	VocabularyFilterMethodRemove VocabularyFilterMethod = "remove"
	VocabularyFilterMethodMask   VocabularyFilterMethod = "mask"
)

type VocabularyInfo struct {
	// The name of the vocabulary.
	VocabularyName *string
	// The language code of the vocabulary entries.
	LanguageCode LanguageCode
	// The processing state of the vocabulary. If the state is READY you can use the
	// vocabulary in a StartTranscriptionJob request.
	VocabularyState VocabularyState
	// The date and time that the vocabulary was last modified.
	LastModifiedTime *time.Time
}

type VocabularyState string

const (
	VocabularyStatePending VocabularyState = "PENDING"
	VocabularyStateReady   VocabularyState = "READY"
	VocabularyStateFailed  VocabularyState = "FAILED"
)