Documentation

Overview

    Package transcribe provides the API client, operations, and parameter types for Amazon Transcribe Service.

    Operations and objects for transcribing speech to text.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-10-26"
    View Source
    const ServiceID = "Transcribe"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon Transcribe Service.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateLanguageModel

                func (c *Client) CreateLanguageModel(ctx context.Context, params *CreateLanguageModelInput, optFns ...func(*Options)) (*CreateLanguageModelOutput, error)

                  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.

                  func (*Client) CreateMedicalVocabulary

                  func (c *Client) CreateMedicalVocabulary(ctx context.Context, params *CreateMedicalVocabularyInput, optFns ...func(*Options)) (*CreateMedicalVocabularyOutput, error)

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

                    func (*Client) CreateVocabulary

                    func (c *Client) CreateVocabulary(ctx context.Context, params *CreateVocabularyInput, optFns ...func(*Options)) (*CreateVocabularyOutput, error)

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

                      func (*Client) CreateVocabularyFilter

                      func (c *Client) CreateVocabularyFilter(ctx context.Context, params *CreateVocabularyFilterInput, optFns ...func(*Options)) (*CreateVocabularyFilterOutput, error)

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

                        func (*Client) DeleteLanguageModel

                        func (c *Client) DeleteLanguageModel(ctx context.Context, params *DeleteLanguageModelInput, optFns ...func(*Options)) (*DeleteLanguageModelOutput, error)

                          Deletes a custom language model using its name.

                          func (*Client) DeleteMedicalTranscriptionJob

                          func (c *Client) DeleteMedicalTranscriptionJob(ctx context.Context, params *DeleteMedicalTranscriptionJobInput, optFns ...func(*Options)) (*DeleteMedicalTranscriptionJobOutput, error)

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

                            func (*Client) DeleteMedicalVocabulary

                            func (c *Client) DeleteMedicalVocabulary(ctx context.Context, params *DeleteMedicalVocabularyInput, optFns ...func(*Options)) (*DeleteMedicalVocabularyOutput, error)

                              Deletes a vocabulary from Amazon Transcribe Medical.

                              func (*Client) DeleteTranscriptionJob

                              func (c *Client) DeleteTranscriptionJob(ctx context.Context, params *DeleteTranscriptionJobInput, optFns ...func(*Options)) (*DeleteTranscriptionJobOutput, error)

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

                                func (*Client) DeleteVocabulary

                                func (c *Client) DeleteVocabulary(ctx context.Context, params *DeleteVocabularyInput, optFns ...func(*Options)) (*DeleteVocabularyOutput, error)

                                  Deletes a vocabulary from Amazon Transcribe.

                                  func (*Client) DeleteVocabularyFilter

                                  func (c *Client) DeleteVocabularyFilter(ctx context.Context, params *DeleteVocabularyFilterInput, optFns ...func(*Options)) (*DeleteVocabularyFilterOutput, error)

                                    Removes a vocabulary filter.

                                    func (*Client) DescribeLanguageModel

                                    func (c *Client) DescribeLanguageModel(ctx context.Context, params *DescribeLanguageModelInput, optFns ...func(*Options)) (*DescribeLanguageModelOutput, error)

                                      Gets information about a single custom language model. Use this information to see details about the language model in your AWS 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.

                                      func (*Client) GetMedicalTranscriptionJob

                                      func (c *Client) GetMedicalTranscriptionJob(ctx context.Context, params *GetMedicalTranscriptionJobInput, optFns ...func(*Options)) (*GetMedicalTranscriptionJobOutput, error)

                                        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.

                                        func (*Client) GetMedicalVocabulary

                                        func (c *Client) GetMedicalVocabulary(ctx context.Context, params *GetMedicalVocabularyInput, optFns ...func(*Options)) (*GetMedicalVocabularyOutput, error)

                                          Retrieves information about a medical vocabulary.

                                          func (*Client) GetTranscriptionJob

                                          func (c *Client) GetTranscriptionJob(ctx context.Context, params *GetTranscriptionJobInput, optFns ...func(*Options)) (*GetTranscriptionJobOutput, error)

                                            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.

                                            func (*Client) GetVocabulary

                                            func (c *Client) GetVocabulary(ctx context.Context, params *GetVocabularyInput, optFns ...func(*Options)) (*GetVocabularyOutput, error)

                                              Gets information about a vocabulary.

                                              func (*Client) GetVocabularyFilter

                                              func (c *Client) GetVocabularyFilter(ctx context.Context, params *GetVocabularyFilterInput, optFns ...func(*Options)) (*GetVocabularyFilterOutput, error)

                                                Returns information about a vocabulary filter.

                                                func (*Client) ListLanguageModels

                                                func (c *Client) ListLanguageModels(ctx context.Context, params *ListLanguageModelsInput, optFns ...func(*Options)) (*ListLanguageModelsOutput, error)

                                                  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.

                                                  func (*Client) ListMedicalTranscriptionJobs

                                                  func (c *Client) ListMedicalTranscriptionJobs(ctx context.Context, params *ListMedicalTranscriptionJobsInput, optFns ...func(*Options)) (*ListMedicalTranscriptionJobsOutput, error)

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

                                                    func (*Client) ListMedicalVocabularies

                                                    func (c *Client) ListMedicalVocabularies(ctx context.Context, params *ListMedicalVocabulariesInput, optFns ...func(*Options)) (*ListMedicalVocabulariesOutput, error)

                                                      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.

                                                      func (*Client) ListTranscriptionJobs

                                                      func (c *Client) ListTranscriptionJobs(ctx context.Context, params *ListTranscriptionJobsInput, optFns ...func(*Options)) (*ListTranscriptionJobsOutput, error)

                                                        Lists transcription jobs with the specified status.

                                                        func (*Client) ListVocabularies

                                                        func (c *Client) ListVocabularies(ctx context.Context, params *ListVocabulariesInput, optFns ...func(*Options)) (*ListVocabulariesOutput, error)

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

                                                          func (*Client) ListVocabularyFilters

                                                          func (c *Client) ListVocabularyFilters(ctx context.Context, params *ListVocabularyFiltersInput, optFns ...func(*Options)) (*ListVocabularyFiltersOutput, error)

                                                            Gets information about vocabulary filters.

                                                            func (*Client) StartMedicalTranscriptionJob

                                                            func (c *Client) StartMedicalTranscriptionJob(ctx context.Context, params *StartMedicalTranscriptionJobInput, optFns ...func(*Options)) (*StartMedicalTranscriptionJobOutput, error)

                                                              Starts a batch job to transcribe medical speech to text.

                                                              func (*Client) StartTranscriptionJob

                                                              func (c *Client) StartTranscriptionJob(ctx context.Context, params *StartTranscriptionJobInput, optFns ...func(*Options)) (*StartTranscriptionJobOutput, error)

                                                                Starts an asynchronous job to transcribe speech to text.

                                                                func (*Client) UpdateMedicalVocabulary

                                                                func (c *Client) UpdateMedicalVocabulary(ctx context.Context, params *UpdateMedicalVocabularyInput, optFns ...func(*Options)) (*UpdateMedicalVocabularyOutput, error)

                                                                  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.

                                                                  func (*Client) UpdateVocabulary

                                                                  func (c *Client) UpdateVocabulary(ctx context.Context, params *UpdateVocabularyInput, optFns ...func(*Options)) (*UpdateVocabularyOutput, error)

                                                                    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.

                                                                    func (*Client) UpdateVocabularyFilter

                                                                    func (c *Client) UpdateVocabularyFilter(ctx context.Context, params *UpdateVocabularyFilterInput, optFns ...func(*Options)) (*UpdateVocabularyFilterOutput, error)

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

                                                                      type CreateLanguageModelInput

                                                                      type CreateLanguageModelInput struct {
                                                                      
                                                                      	// 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 kHz 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 kHz, choose Narrowband.
                                                                      	//
                                                                      	// This member is required.
                                                                      	BaseModelName types.BaseModelName
                                                                      
                                                                      	// Contains the data access role and the Amazon S3 prefixes to read the required
                                                                      	// input files to create a custom language model.
                                                                      	//
                                                                      	// This member is required.
                                                                      	InputDataConfig *types.InputDataConfig
                                                                      
                                                                      	// The language of the input text you're using to train your custom language model.
                                                                      	//
                                                                      	// This member is required.
                                                                      	LanguageCode types.CLMLanguageCode
                                                                      
                                                                      	// The name you choose for your custom language model when you create it.
                                                                      	//
                                                                      	// This member is required.
                                                                      	ModelName *string
                                                                      }

                                                                      type CreateLanguageModelOutput

                                                                      type CreateLanguageModelOutput struct {
                                                                      
                                                                      	// The Amazon Transcribe standard language model, or base model you've used to
                                                                      	// create a custom language model.
                                                                      	BaseModelName types.BaseModelName
                                                                      
                                                                      	// The data access role and Amazon S3 prefixes you've chosen to create your custom
                                                                      	// language model.
                                                                      	InputDataConfig *types.InputDataConfig
                                                                      
                                                                      	// The language code of the text you've used to create a custom language model.
                                                                      	LanguageCode types.CLMLanguageCode
                                                                      
                                                                      	// The name you've chosen for your custom language model.
                                                                      	ModelName *string
                                                                      
                                                                      	// The status of the custom language model. When the status is COMPLETED the model
                                                                      	// is ready to use.
                                                                      	ModelStatus types.ModelStatus
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type CreateMedicalVocabularyInput

                                                                      type CreateMedicalVocabularyInput struct {
                                                                      
                                                                      	// 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.
                                                                      	//
                                                                      	// This member is required.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// The location in Amazon S3 of the text file you use to define your custom
                                                                      	// vocabulary. The URI must be in the same AWS Region as the resource that you're
                                                                      	// calling. Enter information about your VocabularyFileUri in the following format:
                                                                      	// https://s3..amazonaws.com///  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
                                                                      	// (http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#object-keys)
                                                                      	// in the Amazon S3 Developer Guide. For more information about custom
                                                                      	// vocabularies, see Medical Custom Vocabularies
                                                                      	// (http://docs.aws.amazon.com/transcribe/latest/dg/how-it-works.html#how-vocabulary-med).
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyFileUri *string
                                                                      
                                                                      	// The name of the custom vocabulary. This case-sensitive name must be unique
                                                                      	// within an AWS account. If you try to create a vocabulary with the same name as a
                                                                      	// previous vocabulary, you get a ConflictException error.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyName *string
                                                                      }

                                                                      type CreateMedicalVocabularyOutput

                                                                      type CreateMedicalVocabularyOutput struct {
                                                                      
                                                                      	// If the VocabularyState field is FAILED, this field contains information about
                                                                      	// why the job failed.
                                                                      	FailureReason *string
                                                                      
                                                                      	// The language code for the entries in your custom vocabulary. US English (en-US)
                                                                      	// is the only valid language code for Amazon Transcribe Medical.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// The date and time that you created the vocabulary.
                                                                      	LastModifiedTime *time.Time
                                                                      
                                                                      	// The name of the vocabulary. The name must be unique within an AWS account and is
                                                                      	// case sensitive.
                                                                      	VocabularyName *string
                                                                      
                                                                      	// The processing state of your custom vocabulary in Amazon Transcribe Medical. If
                                                                      	// the state is READY, you can use the vocabulary in a StartMedicalTranscriptionJob
                                                                      	// request.
                                                                      	VocabularyState types.VocabularyState
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type CreateVocabularyFilterInput

                                                                      type CreateVocabularyFilterInput struct {
                                                                      
                                                                      	// 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.
                                                                      	//
                                                                      	// This member is required.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// 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.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyFilterName *string
                                                                      
                                                                      	// 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
                                                                      	// (https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html#charsets).
                                                                      	// 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.
                                                                      	VocabularyFilterFileUri *string
                                                                      
                                                                      	// 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
                                                                      	// (https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html#charsets).
                                                                      	// If you provide a list of words in the Words parameter, you can't use the
                                                                      	// VocabularyFilterFileUri parameter.
                                                                      	Words []string
                                                                      }

                                                                      type CreateVocabularyFilterOutput

                                                                      type CreateVocabularyFilterOutput struct {
                                                                      
                                                                      	// The language code of the words in the collection.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// The date and time that the vocabulary filter was modified.
                                                                      	LastModifiedTime *time.Time
                                                                      
                                                                      	// The name of the vocabulary filter.
                                                                      	VocabularyFilterName *string
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type CreateVocabularyInput

                                                                      type CreateVocabularyInput struct {
                                                                      
                                                                      	// The language code of the vocabulary entries.
                                                                      	//
                                                                      	// This member is required.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// The name of the vocabulary. The name must be unique within an AWS 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.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyName *string
                                                                      
                                                                      	// An array of strings that contains the vocabulary entries.
                                                                      	Phrases []string
                                                                      
                                                                      	// 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
                                                                      	// (http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#object-keys)
                                                                      	// in the Amazon S3 Developer Guide. For more information about custom
                                                                      	// vocabularies, see Custom Vocabularies
                                                                      	// (http://docs.aws.amazon.com/transcribe/latest/dg/how-it-works.html#how-vocabulary).
                                                                      	VocabularyFileUri *string
                                                                      }

                                                                      type CreateVocabularyOutput

                                                                      type CreateVocabularyOutput struct {
                                                                      
                                                                      	// If the VocabularyState field is FAILED, this field contains information about
                                                                      	// why the job failed.
                                                                      	FailureReason *string
                                                                      
                                                                      	// The language code of the vocabulary entries.
                                                                      	LanguageCode types.LanguageCode
                                                                      
                                                                      	// The date and time that the vocabulary was created.
                                                                      	LastModifiedTime *time.Time
                                                                      
                                                                      	// The name of the vocabulary.
                                                                      	VocabularyName *string
                                                                      
                                                                      	// The processing state of the vocabulary. When the VocabularyState field contains
                                                                      	// READY the vocabulary is ready to be used in a StartTranscriptionJob request.
                                                                      	VocabularyState types.VocabularyState
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteLanguageModelInput

                                                                      type DeleteLanguageModelInput struct {
                                                                      
                                                                      	// The name of the model you're choosing to delete.
                                                                      	//
                                                                      	// This member is required.
                                                                      	ModelName *string
                                                                      }

                                                                      type DeleteLanguageModelOutput

                                                                      type DeleteLanguageModelOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteMedicalTranscriptionJobInput

                                                                      type DeleteMedicalTranscriptionJobInput struct {
                                                                      
                                                                      	// The name you provide to the DeleteMedicalTranscriptionJob object to delete a
                                                                      	// transcription job.
                                                                      	//
                                                                      	// This member is required.
                                                                      	MedicalTranscriptionJobName *string
                                                                      }

                                                                      type DeleteMedicalTranscriptionJobOutput

                                                                      type DeleteMedicalTranscriptionJobOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteMedicalVocabularyInput

                                                                      type DeleteMedicalVocabularyInput struct {
                                                                      
                                                                      	// The name of the vocabulary that you want to delete.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyName *string
                                                                      }

                                                                      type DeleteMedicalVocabularyOutput

                                                                      type DeleteMedicalVocabularyOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteTranscriptionJobInput

                                                                      type DeleteTranscriptionJobInput struct {
                                                                      
                                                                      	// The name of the transcription job to be deleted.
                                                                      	//
                                                                      	// This member is required.
                                                                      	TranscriptionJobName *string
                                                                      }

                                                                      type DeleteTranscriptionJobOutput

                                                                      type DeleteTranscriptionJobOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteVocabularyFilterInput

                                                                      type DeleteVocabularyFilterInput struct {
                                                                      
                                                                      	// The name of the vocabulary filter to remove.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyFilterName *string
                                                                      }

                                                                      type DeleteVocabularyFilterOutput

                                                                      type DeleteVocabularyFilterOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DeleteVocabularyInput

                                                                      type DeleteVocabularyInput struct {
                                                                      
                                                                      	// The name of the vocabulary to delete.
                                                                      	//
                                                                      	// This member is required.
                                                                      	VocabularyName *string
                                                                      }

                                                                      type DeleteVocabularyOutput

                                                                      type DeleteVocabularyOutput struct {
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DescribeLanguageModelInput

                                                                      type DescribeLanguageModelInput struct {
                                                                      
                                                                      	// The name of the custom language model you submit to get more information.
                                                                      	//
                                                                      	// This member is required.
                                                                      	ModelName *string
                                                                      }

                                                                      type DescribeLanguageModelOutput

                                                                      type DescribeLanguageModelOutput struct {
                                                                      
                                                                      	// The name of the custom language model you requested more information about.
                                                                      	LanguageModel *types.LanguageModel
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type EndpointResolver

                                                                      type EndpointResolver interface {
                                                                      	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                      }

                                                                        EndpointResolver interface for resolving service endpoints.

                                                                        func EndpointResolverFromURL

                                                                        func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                          EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                          type EndpointResolverFunc

                                                                          type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                            EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                            func (EndpointResolverFunc) ResolveEndpoint

                                                                            func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                            type EndpointResolverOptions

                                                                            type EndpointResolverOptions = internalendpoints.Options

                                                                              EndpointResolverOptions is the service endpoint resolver options

                                                                              type GetMedicalTranscriptionJobInput

                                                                              type GetMedicalTranscriptionJobInput struct {
                                                                              
                                                                              	// The name of the medical transcription job.
                                                                              	//
                                                                              	// This member is required.
                                                                              	MedicalTranscriptionJobName *string
                                                                              }

                                                                              type GetMedicalTranscriptionJobOutput

                                                                              type GetMedicalTranscriptionJobOutput struct {
                                                                              
                                                                              	// An object that contains the results of the medical transcription job.
                                                                              	MedicalTranscriptionJob *types.MedicalTranscriptionJob
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type GetMedicalVocabularyInput

                                                                              type GetMedicalVocabularyInput struct {
                                                                              
                                                                              	// The name of the vocabulary that you want information about. The value is case
                                                                              	// sensitive.
                                                                              	//
                                                                              	// This member is required.
                                                                              	VocabularyName *string
                                                                              }

                                                                              type GetMedicalVocabularyOutput

                                                                              type GetMedicalVocabularyOutput struct {
                                                                              
                                                                              	// The location in Amazon S3 where the vocabulary is stored. Use this URI to get
                                                                              	// the contents of the vocabulary. You can download your vocabulary from the URI
                                                                              	// for a limited time.
                                                                              	DownloadUri *string
                                                                              
                                                                              	// If the VocabularyState is FAILED, this field contains information about why the
                                                                              	// job failed.
                                                                              	FailureReason *string
                                                                              
                                                                              	// The valid language code for your vocabulary entries.
                                                                              	LanguageCode types.LanguageCode
                                                                              
                                                                              	// The date and time that the vocabulary was last modified with a text file
                                                                              	// different from the one that was previously used.
                                                                              	LastModifiedTime *time.Time
                                                                              
                                                                              	// The name of the vocabulary returned by Amazon Transcribe Medical.
                                                                              	VocabularyName *string
                                                                              
                                                                              	// The processing state of the vocabulary. If the VocabularyState is READY then you
                                                                              	// can use it in the StartMedicalTranscriptionJob operation.
                                                                              	VocabularyState types.VocabularyState
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type GetTranscriptionJobInput

                                                                              type GetTranscriptionJobInput struct {
                                                                              
                                                                              	// The name of the job.
                                                                              	//
                                                                              	// This member is required.
                                                                              	TranscriptionJobName *string
                                                                              }

                                                                              type GetTranscriptionJobOutput

                                                                              type GetTranscriptionJobOutput struct {
                                                                              
                                                                              	// An object that contains the results of the transcription job.
                                                                              	TranscriptionJob *types.TranscriptionJob
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type GetVocabularyFilterInput

                                                                              type GetVocabularyFilterInput struct {
                                                                              
                                                                              	// The name of the vocabulary filter for which to return information.
                                                                              	//
                                                                              	// This member is required.
                                                                              	VocabularyFilterName *string
                                                                              }

                                                                              type GetVocabularyFilterOutput

                                                                              type GetVocabularyFilterOutput struct {
                                                                              
                                                                              	// The URI of the list of words in the vocabulary filter. You can use this URI to
                                                                              	// get the list of words.
                                                                              	DownloadUri *string
                                                                              
                                                                              	// The language code of the words in the vocabulary filter.
                                                                              	LanguageCode types.LanguageCode
                                                                              
                                                                              	// The date and time that the contents of the vocabulary filter were updated.
                                                                              	LastModifiedTime *time.Time
                                                                              
                                                                              	// The name of the vocabulary filter.
                                                                              	VocabularyFilterName *string
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type GetVocabularyInput

                                                                              type GetVocabularyInput struct {
                                                                              
                                                                              	// The name of the vocabulary to return information about. The name is case
                                                                              	// sensitive.
                                                                              	//
                                                                              	// This member is required.
                                                                              	VocabularyName *string
                                                                              }

                                                                              type GetVocabularyOutput

                                                                              type GetVocabularyOutput struct {
                                                                              
                                                                              	// The S3 location where the vocabulary is stored. Use this URI to get the contents
                                                                              	// of the vocabulary. The URI is available for a limited time.
                                                                              	DownloadUri *string
                                                                              
                                                                              	// If the VocabularyState field is FAILED, this field contains information about
                                                                              	// why the job failed.
                                                                              	FailureReason *string
                                                                              
                                                                              	// The language code of the vocabulary entries.
                                                                              	LanguageCode types.LanguageCode
                                                                              
                                                                              	// The date and time that the vocabulary was last modified.
                                                                              	LastModifiedTime *time.Time
                                                                              
                                                                              	// The name of the vocabulary to return.
                                                                              	VocabularyName *string
                                                                              
                                                                              	// The processing state of the vocabulary.
                                                                              	VocabularyState types.VocabularyState
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type HTTPClient

                                                                              type HTTPClient interface {
                                                                              	Do(*http.Request) (*http.Response, error)
                                                                              }

                                                                              type HTTPSignerV4

                                                                              type HTTPSignerV4 interface {
                                                                              	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                              }

                                                                              type ListLanguageModelsAPIClient

                                                                              type ListLanguageModelsAPIClient interface {
                                                                              	ListLanguageModels(context.Context, *ListLanguageModelsInput, ...func(*Options)) (*ListLanguageModelsOutput, error)
                                                                              }

                                                                                ListLanguageModelsAPIClient is a client that implements the ListLanguageModels operation.

                                                                                type ListLanguageModelsInput

                                                                                type ListLanguageModelsInput struct {
                                                                                
                                                                                	// The maximum number of language models to return in the response. If there are
                                                                                	// fewer results in the list, the response contains only the actual results.
                                                                                	MaxResults *int32
                                                                                
                                                                                	// When specified, the custom language model names returned contain the substring
                                                                                	// you've specified.
                                                                                	NameContains *string
                                                                                
                                                                                	// When included, fetches the next set of jobs if the result of the previous
                                                                                	// request was truncated.
                                                                                	NextToken *string
                                                                                
                                                                                	// 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.
                                                                                	StatusEquals types.ModelStatus
                                                                                }

                                                                                type ListLanguageModelsOutput

                                                                                type ListLanguageModelsOutput struct {
                                                                                
                                                                                	// A list of objects containing information about custom language models.
                                                                                	Models []types.LanguageModel
                                                                                
                                                                                	// The operation returns a page of jobs at a time. The maximum size of the list is
                                                                                	// set by the MaxResults parameter. If there are more language models in the list
                                                                                	// than the page size, Amazon Transcribe returns the NextPage token. Include the
                                                                                	// token in the next request to the operation to return the next page of language
                                                                                	// models.
                                                                                	NextToken *string
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type ListLanguageModelsPaginator

                                                                                type ListLanguageModelsPaginator struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  ListLanguageModelsPaginator is a paginator for ListLanguageModels

                                                                                  func NewListLanguageModelsPaginator

                                                                                  func NewListLanguageModelsPaginator(client ListLanguageModelsAPIClient, params *ListLanguageModelsInput, optFns ...func(*ListLanguageModelsPaginatorOptions)) *ListLanguageModelsPaginator

                                                                                    NewListLanguageModelsPaginator returns a new ListLanguageModelsPaginator

                                                                                    func (*ListLanguageModelsPaginator) HasMorePages

                                                                                    func (p *ListLanguageModelsPaginator) HasMorePages() bool

                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                      func (*ListLanguageModelsPaginator) NextPage

                                                                                      func (p *ListLanguageModelsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListLanguageModelsOutput, error)

                                                                                        NextPage retrieves the next ListLanguageModels page.

                                                                                        type ListLanguageModelsPaginatorOptions

                                                                                        type ListLanguageModelsPaginatorOptions struct {
                                                                                        	// The maximum number of language models to return in the response. If there are
                                                                                        	// fewer results in the list, the response contains only the actual results.
                                                                                        	Limit int32
                                                                                        
                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                        	// that matches the most recent token provided to the service.
                                                                                        	StopOnDuplicateToken bool
                                                                                        }

                                                                                          ListLanguageModelsPaginatorOptions is the paginator options for ListLanguageModels

                                                                                          type ListMedicalTranscriptionJobsAPIClient

                                                                                          type ListMedicalTranscriptionJobsAPIClient interface {
                                                                                          	ListMedicalTranscriptionJobs(context.Context, *ListMedicalTranscriptionJobsInput, ...func(*Options)) (*ListMedicalTranscriptionJobsOutput, error)
                                                                                          }

                                                                                            ListMedicalTranscriptionJobsAPIClient is a client that implements the ListMedicalTranscriptionJobs operation.

                                                                                            type ListMedicalTranscriptionJobsInput

                                                                                            type ListMedicalTranscriptionJobsInput struct {
                                                                                            
                                                                                            	// When specified, the jobs returned in the list are limited to jobs whose name
                                                                                            	// contains the specified string.
                                                                                            	JobNameContains *string
                                                                                            
                                                                                            	// The maximum number of medical transcription jobs to return in the response. IF
                                                                                            	// there are fewer results in the list, this response contains only the actual
                                                                                            	// results.
                                                                                            	MaxResults *int32
                                                                                            
                                                                                            	// If you a receive a truncated result in the previous request of
                                                                                            	// ListMedicalTranscriptionJobs, include NextToken to fetch the next set of jobs.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// 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.
                                                                                            	Status types.TranscriptionJobStatus
                                                                                            }

                                                                                            type ListMedicalTranscriptionJobsOutput

                                                                                            type ListMedicalTranscriptionJobsOutput struct {
                                                                                            
                                                                                            	// A list of objects containing summary information for a transcription job.
                                                                                            	MedicalTranscriptionJobSummaries []types.MedicalTranscriptionJobSummary
                                                                                            
                                                                                            	// The ListMedicalTranscriptionJobs operation returns a page of jobs at a time. The
                                                                                            	// maximum size of the page is set by the MaxResults parameter. If the number of
                                                                                            	// jobs exceeds what can fit on a page, Amazon Transcribe Medical returns the
                                                                                            	// NextPage token. Include the token in the next request to the
                                                                                            	// ListMedicalTranscriptionJobs operation to return in the next page of jobs.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// The requested status of the medical transcription jobs returned.
                                                                                            	Status types.TranscriptionJobStatus
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type ListMedicalTranscriptionJobsPaginator

                                                                                            type ListMedicalTranscriptionJobsPaginator struct {
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                              ListMedicalTranscriptionJobsPaginator is a paginator for ListMedicalTranscriptionJobs

                                                                                              func NewListMedicalTranscriptionJobsPaginator

                                                                                                NewListMedicalTranscriptionJobsPaginator returns a new ListMedicalTranscriptionJobsPaginator

                                                                                                func (*ListMedicalTranscriptionJobsPaginator) HasMorePages

                                                                                                func (p *ListMedicalTranscriptionJobsPaginator) HasMorePages() bool

                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                  func (*ListMedicalTranscriptionJobsPaginator) NextPage

                                                                                                    NextPage retrieves the next ListMedicalTranscriptionJobs page.

                                                                                                    type ListMedicalTranscriptionJobsPaginatorOptions

                                                                                                    type ListMedicalTranscriptionJobsPaginatorOptions struct {
                                                                                                    	// The maximum number of medical transcription jobs to return in the response. IF
                                                                                                    	// there are fewer results in the list, this response contains only the actual
                                                                                                    	// results.
                                                                                                    	Limit int32
                                                                                                    
                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                    	StopOnDuplicateToken bool
                                                                                                    }

                                                                                                      ListMedicalTranscriptionJobsPaginatorOptions is the paginator options for ListMedicalTranscriptionJobs

                                                                                                      type ListMedicalVocabulariesAPIClient

                                                                                                      type ListMedicalVocabulariesAPIClient interface {
                                                                                                      	ListMedicalVocabularies(context.Context, *ListMedicalVocabulariesInput, ...func(*Options)) (*ListMedicalVocabulariesOutput, error)
                                                                                                      }

                                                                                                        ListMedicalVocabulariesAPIClient is a client that implements the ListMedicalVocabularies operation.

                                                                                                        type ListMedicalVocabulariesInput

                                                                                                        type ListMedicalVocabulariesInput struct {
                                                                                                        
                                                                                                        	// The maximum number of vocabularies to return in the response.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Returns vocabularies whose names contain the specified string. The search is not
                                                                                                        	// case sensitive. ListMedicalVocabularies returns both "vocabularyname" and
                                                                                                        	// "VocabularyName".
                                                                                                        	NameContains *string
                                                                                                        
                                                                                                        	// If the result of your previous request to ListMedicalVocabularies was truncated,
                                                                                                        	// include the NextToken to fetch the next set of vocabularies.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// 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.
                                                                                                        	StateEquals types.VocabularyState
                                                                                                        }

                                                                                                        type ListMedicalVocabulariesOutput

                                                                                                        type ListMedicalVocabulariesOutput struct {
                                                                                                        
                                                                                                        	// The ListMedicalVocabularies operation returns a page of vocabularies at a time.
                                                                                                        	// You set the maximum number of vocabularies to return on a page with the
                                                                                                        	// MaxResults parameter. If there are more jobs in the list will fit on a page,
                                                                                                        	// Amazon Transcribe Medical returns the NextPage token. To return the next page of
                                                                                                        	// vocabularies, include the token in the next request to the
                                                                                                        	// ListMedicalVocabularies operation .
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// The requested vocabulary state.
                                                                                                        	Status types.VocabularyState
                                                                                                        
                                                                                                        	// A list of objects that describe the vocabularies that match your search
                                                                                                        	// criteria.
                                                                                                        	Vocabularies []types.VocabularyInfo
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListMedicalVocabulariesPaginator

                                                                                                        type ListMedicalVocabulariesPaginator struct {
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          ListMedicalVocabulariesPaginator is a paginator for ListMedicalVocabularies

                                                                                                          func NewListMedicalVocabulariesPaginator

                                                                                                            NewListMedicalVocabulariesPaginator returns a new ListMedicalVocabulariesPaginator

                                                                                                            func (*ListMedicalVocabulariesPaginator) HasMorePages

                                                                                                            func (p *ListMedicalVocabulariesPaginator) HasMorePages() bool

                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                              func (*ListMedicalVocabulariesPaginator) NextPage

                                                                                                                NextPage retrieves the next ListMedicalVocabularies page.

                                                                                                                type ListMedicalVocabulariesPaginatorOptions

                                                                                                                type ListMedicalVocabulariesPaginatorOptions struct {
                                                                                                                	// The maximum number of vocabularies to return in the response.
                                                                                                                	Limit int32
                                                                                                                
                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                	StopOnDuplicateToken bool
                                                                                                                }

                                                                                                                  ListMedicalVocabulariesPaginatorOptions is the paginator options for ListMedicalVocabularies

                                                                                                                  type ListTranscriptionJobsAPIClient

                                                                                                                  type ListTranscriptionJobsAPIClient interface {
                                                                                                                  	ListTranscriptionJobs(context.Context, *ListTranscriptionJobsInput, ...func(*Options)) (*ListTranscriptionJobsOutput, error)
                                                                                                                  }

                                                                                                                    ListTranscriptionJobsAPIClient is a client that implements the ListTranscriptionJobs operation.

                                                                                                                    type ListTranscriptionJobsInput

                                                                                                                    type ListTranscriptionJobsInput struct {
                                                                                                                    
                                                                                                                    	// When specified, the jobs returned in the list are limited to jobs whose name
                                                                                                                    	// contains the specified string.
                                                                                                                    	JobNameContains *string
                                                                                                                    
                                                                                                                    	// The maximum number of jobs to return in the response. If there are fewer results
                                                                                                                    	// in the list, this response contains only the actual results.
                                                                                                                    	MaxResults *int32
                                                                                                                    
                                                                                                                    	// If the result of the previous request to ListTranscriptionJobs was truncated,
                                                                                                                    	// include the NextToken to fetch the next set of jobs.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// 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.
                                                                                                                    	Status types.TranscriptionJobStatus
                                                                                                                    }

                                                                                                                    type ListTranscriptionJobsOutput

                                                                                                                    type ListTranscriptionJobsOutput struct {
                                                                                                                    
                                                                                                                    	// The ListTranscriptionJobs operation returns a page of jobs at a time. The
                                                                                                                    	// maximum size of the page is set by the MaxResults parameter. If there are more
                                                                                                                    	// jobs in the list than the page size, Amazon Transcribe returns the NextPage
                                                                                                                    	// token. Include the token in the next request to the ListTranscriptionJobs
                                                                                                                    	// operation to return in the next page of jobs.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// The requested status of the jobs returned.
                                                                                                                    	Status types.TranscriptionJobStatus
                                                                                                                    
                                                                                                                    	// A list of objects containing summary information for a transcription job.
                                                                                                                    	TranscriptionJobSummaries []types.TranscriptionJobSummary
                                                                                                                    
                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                    }

                                                                                                                    type ListTranscriptionJobsPaginator

                                                                                                                    type ListTranscriptionJobsPaginator struct {
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                      ListTranscriptionJobsPaginator is a paginator for ListTranscriptionJobs

                                                                                                                      func NewListTranscriptionJobsPaginator

                                                                                                                        NewListTranscriptionJobsPaginator returns a new ListTranscriptionJobsPaginator

                                                                                                                        func (*ListTranscriptionJobsPaginator) HasMorePages

                                                                                                                        func (p *ListTranscriptionJobsPaginator) HasMorePages() bool

                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                          func (*ListTranscriptionJobsPaginator) NextPage

                                                                                                                            NextPage retrieves the next ListTranscriptionJobs page.

                                                                                                                            type ListTranscriptionJobsPaginatorOptions

                                                                                                                            type ListTranscriptionJobsPaginatorOptions struct {
                                                                                                                            	// The maximum number of jobs to return in the response. If there are fewer results
                                                                                                                            	// in the list, this response contains only the actual results.
                                                                                                                            	Limit int32
                                                                                                                            
                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                            }

                                                                                                                              ListTranscriptionJobsPaginatorOptions is the paginator options for ListTranscriptionJobs

                                                                                                                              type ListVocabulariesAPIClient

                                                                                                                              type ListVocabulariesAPIClient interface {
                                                                                                                              	ListVocabularies(context.Context, *ListVocabulariesInput, ...func(*Options)) (*ListVocabulariesOutput, error)
                                                                                                                              }

                                                                                                                                ListVocabulariesAPIClient is a client that implements the ListVocabularies operation.

                                                                                                                                type ListVocabulariesInput

                                                                                                                                type ListVocabulariesInput struct {
                                                                                                                                
                                                                                                                                	// The maximum number of vocabularies to return in the response. If there are fewer
                                                                                                                                	// results in the list, this response contains only the actual results.
                                                                                                                                	MaxResults *int32
                                                                                                                                
                                                                                                                                	// 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.
                                                                                                                                	NameContains *string
                                                                                                                                
                                                                                                                                	// If the result of the previous request to ListVocabularies was truncated, include
                                                                                                                                	// the NextToken to fetch the next set of jobs.
                                                                                                                                	NextToken *string
                                                                                                                                
                                                                                                                                	// When specified, only returns vocabularies with the VocabularyState field equal
                                                                                                                                	// to the specified state.
                                                                                                                                	StateEquals types.VocabularyState
                                                                                                                                }

                                                                                                                                type ListVocabulariesOutput

                                                                                                                                type ListVocabulariesOutput struct {
                                                                                                                                
                                                                                                                                	// The ListVocabularies operation returns a page of vocabularies at a time. The
                                                                                                                                	// maximum size of the page is set in the MaxResults parameter. If there are more
                                                                                                                                	// jobs in the list than will fit on the page, Amazon Transcribe returns the
                                                                                                                                	// NextPage token. To return in the next page of jobs, include the token in the
                                                                                                                                	// next request to the ListVocabularies operation.
                                                                                                                                	NextToken *string
                                                                                                                                
                                                                                                                                	// The requested vocabulary state.
                                                                                                                                	Status types.VocabularyState
                                                                                                                                
                                                                                                                                	// A list of objects that describe the vocabularies that match the search criteria
                                                                                                                                	// in the request.
                                                                                                                                	Vocabularies []types.VocabularyInfo
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type ListVocabulariesPaginator

                                                                                                                                type ListVocabulariesPaginator struct {
                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                }

                                                                                                                                  ListVocabulariesPaginator is a paginator for ListVocabularies

                                                                                                                                  func NewListVocabulariesPaginator

                                                                                                                                  func NewListVocabulariesPaginator(client ListVocabulariesAPIClient, params *ListVocabulariesInput, optFns ...func(*ListVocabulariesPaginatorOptions)) *ListVocabulariesPaginator

                                                                                                                                    NewListVocabulariesPaginator returns a new ListVocabulariesPaginator

                                                                                                                                    func (*ListVocabulariesPaginator) HasMorePages

                                                                                                                                    func (p *ListVocabulariesPaginator) HasMorePages() bool

                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                      func (*ListVocabulariesPaginator) NextPage

                                                                                                                                      func (p *ListVocabulariesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVocabulariesOutput, error)

                                                                                                                                        NextPage retrieves the next ListVocabularies page.

                                                                                                                                        type ListVocabulariesPaginatorOptions

                                                                                                                                        type ListVocabulariesPaginatorOptions struct {
                                                                                                                                        	// The maximum number of vocabularies to return in the response. If there are fewer
                                                                                                                                        	// results in the list, this response contains only the actual results.
                                                                                                                                        	Limit int32
                                                                                                                                        
                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                        }

                                                                                                                                          ListVocabulariesPaginatorOptions is the paginator options for ListVocabularies

                                                                                                                                          type ListVocabularyFiltersAPIClient

                                                                                                                                          type ListVocabularyFiltersAPIClient interface {
                                                                                                                                          	ListVocabularyFilters(context.Context, *ListVocabularyFiltersInput, ...func(*Options)) (*ListVocabularyFiltersOutput, error)
                                                                                                                                          }

                                                                                                                                            ListVocabularyFiltersAPIClient is a client that implements the ListVocabularyFilters operation.

                                                                                                                                            type ListVocabularyFiltersInput

                                                                                                                                            type ListVocabularyFiltersInput struct {
                                                                                                                                            
                                                                                                                                            	// The maximum number of filters to return in the response. If there are fewer
                                                                                                                                            	// results in the list, this response contains only the actual results.
                                                                                                                                            	MaxResults *int32
                                                                                                                                            
                                                                                                                                            	// Filters the response so that it only contains vocabulary filters whose name
                                                                                                                                            	// contains the specified string.
                                                                                                                                            	NameContains *string
                                                                                                                                            
                                                                                                                                            	// If the result of the previous request to ListVocabularyFilters was truncated,
                                                                                                                                            	// include the NextToken to fetch the next set of collections.
                                                                                                                                            	NextToken *string
                                                                                                                                            }

                                                                                                                                            type ListVocabularyFiltersOutput

                                                                                                                                            type ListVocabularyFiltersOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ListVocabularyFilters operation returns a page of collections at a time. The
                                                                                                                                            	// maximum size of the page is set by the MaxResults parameter. If there are more
                                                                                                                                            	// jobs in the list than the page size, Amazon Transcribe returns the NextPage
                                                                                                                                            	// token. Include the token in the next request to the ListVocabularyFilters
                                                                                                                                            	// operation to return in the next page of jobs.
                                                                                                                                            	NextToken *string
                                                                                                                                            
                                                                                                                                            	// The list of vocabulary filters. It contains at most MaxResults number of
                                                                                                                                            	// filters. If there are more filters, call the ListVocabularyFilters operation
                                                                                                                                            	// again with the NextToken parameter in the request set to the value of the
                                                                                                                                            	// NextToken field in the response.
                                                                                                                                            	VocabularyFilters []types.VocabularyFilterInfo
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type ListVocabularyFiltersPaginator

                                                                                                                                            type ListVocabularyFiltersPaginator struct {
                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                            }

                                                                                                                                              ListVocabularyFiltersPaginator is a paginator for ListVocabularyFilters

                                                                                                                                              func NewListVocabularyFiltersPaginator

                                                                                                                                                NewListVocabularyFiltersPaginator returns a new ListVocabularyFiltersPaginator

                                                                                                                                                func (*ListVocabularyFiltersPaginator) HasMorePages

                                                                                                                                                func (p *ListVocabularyFiltersPaginator) HasMorePages() bool

                                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                  func (*ListVocabularyFiltersPaginator) NextPage

                                                                                                                                                    NextPage retrieves the next ListVocabularyFilters page.

                                                                                                                                                    type ListVocabularyFiltersPaginatorOptions

                                                                                                                                                    type ListVocabularyFiltersPaginatorOptions struct {
                                                                                                                                                    	// The maximum number of filters to return in the response. If there are fewer
                                                                                                                                                    	// results in the list, this response contains only the actual results.
                                                                                                                                                    	Limit int32
                                                                                                                                                    
                                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                                    }

                                                                                                                                                      ListVocabularyFiltersPaginatorOptions is the paginator options for ListVocabularyFilters

                                                                                                                                                      type Options

                                                                                                                                                      type Options struct {
                                                                                                                                                      	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                      	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                      	// modify this list for per operation behavior.
                                                                                                                                                      	APIOptions []func(*middleware.Stack) error
                                                                                                                                                      
                                                                                                                                                      	// Configures the events that will be sent to the configured logger.
                                                                                                                                                      	ClientLogMode aws.ClientLogMode
                                                                                                                                                      
                                                                                                                                                      	// The credentials object to use when signing requests.
                                                                                                                                                      	Credentials aws.CredentialsProvider
                                                                                                                                                      
                                                                                                                                                      	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                      	EndpointOptions EndpointResolverOptions
                                                                                                                                                      
                                                                                                                                                      	// The service endpoint resolver.
                                                                                                                                                      	EndpointResolver EndpointResolver
                                                                                                                                                      
                                                                                                                                                      	// Signature Version 4 (SigV4) Signer
                                                                                                                                                      	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                      
                                                                                                                                                      	// The logger writer interface to write logging messages to.
                                                                                                                                                      	Logger logging.Logger
                                                                                                                                                      
                                                                                                                                                      	// The region to send requests to. (Required)
                                                                                                                                                      	Region string
                                                                                                                                                      
                                                                                                                                                      	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                      	// failures. When nil the API client will use a default retryer.
                                                                                                                                                      	Retryer aws.Retryer
                                                                                                                                                      
                                                                                                                                                      	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                      	// implementation if nil.
                                                                                                                                                      	HTTPClient HTTPClient
                                                                                                                                                      }

                                                                                                                                                      func (Options) Copy

                                                                                                                                                      func (o Options) Copy() Options

                                                                                                                                                        Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                        type ResolveEndpoint

                                                                                                                                                        type ResolveEndpoint struct {
                                                                                                                                                        	Resolver EndpointResolver
                                                                                                                                                        	Options  EndpointResolverOptions
                                                                                                                                                        }

                                                                                                                                                        func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                        func (*ResolveEndpoint) ID

                                                                                                                                                        func (*ResolveEndpoint) ID() string

                                                                                                                                                        type StartMedicalTranscriptionJobInput

                                                                                                                                                        type StartMedicalTranscriptionJobInput struct {
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// Describes the input media file in a transcription request.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Media *types.Media
                                                                                                                                                        
                                                                                                                                                        	// 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 AWS
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	MedicalTranscriptionJobName *string
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        	// (https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user).
                                                                                                                                                        	// You can specify an AWS 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	OutputBucketName *string
                                                                                                                                                        
                                                                                                                                                        	// The medical specialty of any clinician speaking in the input media.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Specialty types.Specialty
                                                                                                                                                        
                                                                                                                                                        	// 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, e.g., for clinical
                                                                                                                                                        	// notes.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Type types.Type
                                                                                                                                                        
                                                                                                                                                        	// The audio format of the input media file.
                                                                                                                                                        	MediaFormat types.MediaFormat
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	MediaSampleRateHertz *int32
                                                                                                                                                        
                                                                                                                                                        	// The Amazon Resource Name (ARN) of the AWS 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.
                                                                                                                                                        	OutputEncryptionKMSKeyId *string
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	OutputKey *string
                                                                                                                                                        
                                                                                                                                                        	// Optional settings for the medical transcription job.
                                                                                                                                                        	Settings *types.MedicalTranscriptionSetting
                                                                                                                                                        }

                                                                                                                                                        type StartMedicalTranscriptionJobOutput

                                                                                                                                                        type StartMedicalTranscriptionJobOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// A batch job submitted to transcribe medical speech to text.
                                                                                                                                                        	MedicalTranscriptionJob *types.MedicalTranscriptionJob
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        type StartTranscriptionJobInput

                                                                                                                                                        type StartTranscriptionJobInput struct {
                                                                                                                                                        
                                                                                                                                                        	// An object that describes the input media for a transcription job.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Media *types.Media
                                                                                                                                                        
                                                                                                                                                        	// 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 AWS account. If you try to
                                                                                                                                                        	// create a transcription job with the same name as a previous transcription job,
                                                                                                                                                        	// you get a ConflictException error.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	TranscriptionJobName *string
                                                                                                                                                        
                                                                                                                                                        	// An object that contains the request parameters for content redaction.
                                                                                                                                                        	ContentRedaction *types.ContentRedaction
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	IdentifyLanguage *bool
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	JobExecutionSettings *types.JobExecutionSettings
                                                                                                                                                        
                                                                                                                                                        	// The language code for the language used in the input media file.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	LanguageOptions []types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// The format of the input media file.
                                                                                                                                                        	MediaFormat types.MediaFormat
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	MediaSampleRateHertz *int32
                                                                                                                                                        
                                                                                                                                                        	// Choose the custom language model you use for your transcription job in this
                                                                                                                                                        	// parameter.
                                                                                                                                                        	ModelSettings *types.ModelSettings
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        	// (https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user).
                                                                                                                                                        	// You can specify an AWS 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.
                                                                                                                                                        	OutputBucketName *string
                                                                                                                                                        
                                                                                                                                                        	// The Amazon Resource Name (ARN) of the AWS 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.
                                                                                                                                                        	OutputEncryptionKMSKeyId *string
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	OutputKey *string
                                                                                                                                                        
                                                                                                                                                        	// A Settings object that provides optional settings for a transcription job.
                                                                                                                                                        	Settings *types.Settings
                                                                                                                                                        }

                                                                                                                                                        type StartTranscriptionJobOutput

                                                                                                                                                        type StartTranscriptionJobOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// An object containing details of the asynchronous transcription job.
                                                                                                                                                        	TranscriptionJob *types.TranscriptionJob
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        type UpdateMedicalVocabularyInput

                                                                                                                                                        type UpdateMedicalVocabularyInput struct {
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	VocabularyName *string
                                                                                                                                                        
                                                                                                                                                        	// The location in Amazon S3 of the text file that contains the you use for your
                                                                                                                                                        	// custom vocabulary. The URI must be in the same AWS Region as the resource that
                                                                                                                                                        	// you are calling. The following is the format for a URI:
                                                                                                                                                        	// https://s3..amazonaws.com///  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
                                                                                                                                                        	// (http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#object-keys)
                                                                                                                                                        	// in the Amazon S3 Developer Guide. For more information about custom vocabularies
                                                                                                                                                        	// in Amazon Transcribe Medical, see Medical Custom Vocabularies
                                                                                                                                                        	// (http://docs.aws.amazon.com/transcribe/latest/dg/how-it-works.html#how-vocabulary).
                                                                                                                                                        	VocabularyFileUri *string
                                                                                                                                                        }

                                                                                                                                                        type UpdateMedicalVocabularyOutput

                                                                                                                                                        type UpdateMedicalVocabularyOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// The language code for the language of the text file used to update the custom
                                                                                                                                                        	// vocabulary. US English (en-US) is the only language supported in Amazon
                                                                                                                                                        	// Transcribe Medical.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// The date and time that the vocabulary was updated.
                                                                                                                                                        	LastModifiedTime *time.Time
                                                                                                                                                        
                                                                                                                                                        	// The name of the updated vocabulary.
                                                                                                                                                        	VocabularyName *string
                                                                                                                                                        
                                                                                                                                                        	// The processing state of the update to the vocabulary. When the VocabularyState
                                                                                                                                                        	// field is READY, the vocabulary is ready to be used in a
                                                                                                                                                        	// StartMedicalTranscriptionJob request.
                                                                                                                                                        	VocabularyState types.VocabularyState
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        type UpdateVocabularyFilterInput

                                                                                                                                                        type UpdateVocabularyFilterInput struct {
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	VocabularyFilterName *string
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        	// (https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html#charsets).
                                                                                                                                                        	// 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.
                                                                                                                                                        	VocabularyFilterFileUri *string
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        	// (https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html#charsets).
                                                                                                                                                        	// If you provide a list of words in the Words parameter, you can't use the
                                                                                                                                                        	// VocabularyFilterFileUri parameter.
                                                                                                                                                        	Words []string
                                                                                                                                                        }

                                                                                                                                                        type UpdateVocabularyFilterOutput

                                                                                                                                                        type UpdateVocabularyFilterOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// The language code of the words in the vocabulary filter.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// The date and time that the vocabulary filter was updated.
                                                                                                                                                        	LastModifiedTime *time.Time
                                                                                                                                                        
                                                                                                                                                        	// The name of the updated vocabulary filter.
                                                                                                                                                        	VocabularyFilterName *string
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        type UpdateVocabularyInput

                                                                                                                                                        type UpdateVocabularyInput struct {
                                                                                                                                                        
                                                                                                                                                        	// The language code of the vocabulary entries.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// 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.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	VocabularyName *string
                                                                                                                                                        
                                                                                                                                                        	// An array of strings containing the vocabulary entries.
                                                                                                                                                        	Phrases []string
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        	// (http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#object-keys)
                                                                                                                                                        	// in the Amazon S3 Developer Guide. For more information about custom
                                                                                                                                                        	// vocabularies, see Custom Vocabularies
                                                                                                                                                        	// (http://docs.aws.amazon.com/transcribe/latest/dg/how-it-works.html#how-vocabulary).
                                                                                                                                                        	VocabularyFileUri *string
                                                                                                                                                        }

                                                                                                                                                        type UpdateVocabularyOutput

                                                                                                                                                        type UpdateVocabularyOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// The language code of the vocabulary entries.
                                                                                                                                                        	LanguageCode types.LanguageCode
                                                                                                                                                        
                                                                                                                                                        	// The date and time that the vocabulary was updated.
                                                                                                                                                        	LastModifiedTime *time.Time
                                                                                                                                                        
                                                                                                                                                        	// The name of the vocabulary that was updated.
                                                                                                                                                        	VocabularyName *string
                                                                                                                                                        
                                                                                                                                                        	// The processing state of the vocabulary. When the VocabularyState field contains
                                                                                                                                                        	// READY the vocabulary is ready to be used in a StartTranscriptionJob request.
                                                                                                                                                        	VocabularyState types.VocabularyState
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        Directories

                                                                                                                                                        Path Synopsis
                                                                                                                                                        internal