speechtotextv1

type AcousticModel struct {

	// The customization ID (GUID) of the custom acoustic model. The **Create a custom acoustic model** method returns only
	// this field of the object; it does not return the other fields.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The date and time in Coordinated Universal Time (UTC) at which the custom acoustic model was created. The value is
	// provided in full ISO 8601 format (`YYYY-MM-DDThh:mm:ss.sTZD`).
	Created *string `json:"created,omitempty"`

	// The language identifier of the custom acoustic model (for example, `en-US`).
	Language *string `json:"language,omitempty"`

	// A list of the available versions of the custom acoustic model. Each element of the array indicates a version of the
	// base model with which the custom model can be used. Multiple versions exist only if the custom model has been
	// upgraded; otherwise, only a single version is shown.
	Versions []string `json:"versions,omitempty"`

	// The GUID of the credentials for the instance of the service that owns the custom acoustic model.
	Owner *string `json:"owner,omitempty"`

	// The name of the custom acoustic model.
	Name *string `json:"name,omitempty"`

	// The description of the custom acoustic model.
	Description *string `json:"description,omitempty"`

	// The name of the language model for which the custom acoustic model was created.
	BaseModelName *string `json:"base_model_name,omitempty"`

	// The current status of the custom acoustic model:
	// * `pending`: The model was created but is waiting either for training data to be added or for the service to finish
	// analyzing added data.
	// * `ready`: The model contains data and is ready to be trained.
	// * `training`: The model is currently being trained.
	// * `available`: The model is trained and ready to use.
	// * `upgrading`: The model is currently being upgraded.
	// * `failed`: Training of the model failed.
	Status *string `json:"status,omitempty"`

	// A percentage that indicates the progress of the custom acoustic model's current training. A value of `100` means
	// that the model is fully trained. **Note:** The `progress` field does not currently reflect the progress of the
	// training. The field changes from `0` to `100` when training is complete.
	Progress *int64 `json:"progress,omitempty"`

	// If the request included unknown parameters, the following message: `Unexpected query parameter(s) ['parameters']
	// detected`, where `parameters` is a list that includes a quoted string for each unknown parameter.
	Warnings *string `json:"warnings,omitempty"`
}

type AcousticModels struct {

	// An array of `AcousticModel` objects that provides information about each available custom acoustic model. The array
	// is empty if the requesting credentials own no custom acoustic models (if no language is specified) or own no custom
	// acoustic models for the specified language.
	Customizations []AcousticModel `json:"customizations" validate:"required"`
}

type AddAudioOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the new audio resource for the custom acoustic model. Use a localized name that matches the language of
	// the custom model and reflects the contents of the resource.
	// * Include a maximum of 128 characters in the name.
	// * Do not include spaces, slashes, or backslashes in the name.
	// * Do not use the name of an audio resource that has already been added to the custom model.
	AudioName *string `json:"audio_name" validate:"required"`

	// The audio resource that is to be added to the custom acoustic model, an individual audio file or an archive file.
	AudioResource *io.ReadCloser `json:"audio_resource" validate:"required"`

	// **For an archive-type resource,** specify the format of the audio files that are contained in the archive file if
	// they are of type `audio/alaw`, `audio/basic`, `audio/l16`, or `audio/mulaw`. Include the `rate`, `channels`, and
	// `endianness` parameters where necessary. In this case, all audio files that are contained in the archive file must
	// be of the indicated type.
	//
	// For all other audio formats, you can omit the header. In this case, the audio files can be of multiple types as long
	// as they are not of the types listed in the previous paragraph.
	//
	// The parameter accepts all of the audio formats that are supported for use with speech recognition. For more
	// information, see **Content types for audio-type resources** in the method description.
	//
	// **For an audio-type resource,** omit the header.
	ContainedContentType *string `json:"Contained-Content-Type,omitempty"`

	// If `true`, the specified audio resource overwrites an existing audio resource with the same name. If `false`, the
	// request fails if an audio resource with the same name already exists. The parameter has no effect if an audio
	// resource with the same name does not already exist.
	AllowOverwrite *bool `json:"allow_overwrite,omitempty"`

	// For an audio-type resource, the format (MIME type) of the audio. For more information, see **Content types for
	// audio-type resources** in the method description.
	//
	// For an archive-type resource, the media type of the archive file. For more information, see **Content types for
	// archive-type resources** in the method description.
	ContentType *string `json:"Content-Type,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type AddCorpusOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the new corpus for the custom language model. Use a localized name that matches the language of the
	// custom model and reflects the contents of the corpus.
	// * Include a maximum of 128 characters in the name.
	// * Do not include spaces, slashes, or backslashes in the name.
	// * Do not use the name of an existing corpus or grammar that is already defined for the custom model.
	// * Do not use the name `user`, which is reserved by the service to denote custom words that are added or modified by
	// the user.
	CorpusName *string `json:"corpus_name" validate:"required"`

	// A plain text file that contains the training data for the corpus. Encode the file in UTF-8 if it contains non-ASCII
	// characters; the service assumes UTF-8 encoding if it encounters non-ASCII characters.
	//
	// Make sure that you know the character encoding of the file. You must use that encoding when working with the words
	// in the custom language model. For more information, see [Character
	// encoding](https://cloud.ibm.com/docs/services/speech-to-text/language-resource.html#charEncoding).
	//
	// With the `curl` command, use the `--data-binary` option to upload the file for the request.
	CorpusFile *os.File `json:"corpus_file" validate:"required"`

	// If `true`, the specified corpus overwrites an existing corpus with the same name. If `false`, the request fails if a
	// corpus with the same name already exists. The parameter has no effect if a corpus with the same name does not
	// already exist.
	AllowOverwrite *bool `json:"allow_overwrite,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type AddGrammarOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the new grammar for the custom language model. Use a localized name that matches the language of the
	// custom model and reflects the contents of the grammar.
	// * Include a maximum of 128 characters in the name.
	// * Do not include spaces, slashes, or backslashes in the name.
	// * Do not use the name of an existing grammar or corpus that is already defined for the custom model.
	// * Do not use the name `user`, which is reserved by the service to denote custom words that are added or modified by
	// the user.
	GrammarName *string `json:"grammar_name" validate:"required"`

	// A plain text file that contains the grammar in the format specified by the `Content-Type` header. Encode the file in
	// UTF-8 (ASCII is a subset of UTF-8). Using any other encoding can lead to issues when compiling the grammar or to
	// unexpected results in decoding. The service ignores an encoding that is specified in the header of the grammar.
	GrammarFile *io.ReadCloser `json:"grammar_file" validate:"required"`

	// The format (MIME type) of the grammar file:
	// * `application/srgs` for Augmented Backus-Naur Form (ABNF), which uses a plain-text representation that is similar
	// to traditional BNF grammars.
	// * `application/srgs+xml` for XML Form, which uses XML elements to represent the grammar.
	ContentType *string `json:"Content-Type" validate:"required"`

	// If `true`, the specified grammar overwrites an existing grammar with the same name. If `false`, the request fails if
	// a grammar with the same name already exists. The parameter has no effect if a grammar with the same name does not
	// already exist.
	AllowOverwrite *bool `json:"allow_overwrite,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type AddWordOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The custom word that is to be added to or updated in the custom language model. Do not include spaces in the word.
	// Use a `-` (dash) or `_` (underscore) to connect the tokens of compound words. URL-encode the word if it includes
	// non-ASCII characters. For more information, see [Character
	// encoding](https://cloud.ibm.com/docs/services/speech-to-text/language-resource.html#charEncoding).
	WordName *string `json:"word_name" validate:"required"`

	// For the **Add custom words** method, you must specify the custom word that is to be added to or updated in the
	// custom model. Do not include spaces in the word. Use a `-` (dash) or `_` (underscore) to connect the tokens of
	// compound words.
	//
	// Omit this parameter for the **Add a custom word** method.
	Word *string `json:"word,omitempty"`

	// An array of sounds-like pronunciations for the custom word. Specify how words that are difficult to pronounce,
	// foreign words, acronyms, and so on can be pronounced by users.
	// * For a word that is not in the service's base vocabulary, omit the parameter to have the service automatically
	// generate a sounds-like pronunciation for the word.
	// * For a word that is in the service's base vocabulary, use the parameter to specify additional pronunciations for
	// the word. You cannot override the default pronunciation of a word; pronunciations you add augment the pronunciation
	// from the base vocabulary.
	//
	// A word can have at most five sounds-like pronunciations. A pronunciation can include at most 40 characters not
	// including spaces.
	SoundsLike []string `json:"sounds_like,omitempty"`

	// An alternative spelling for the custom word when it appears in a transcript. Use the parameter when you want the
	// word to have a spelling that is different from its usual representation or from its spelling in corpora training
	// data.
	DisplayAs *string `json:"display_as,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type AddWordsOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// An array of `CustomWord` objects that provides information about each custom word that is to be added to or updated
	// in the custom language model.
	Words []CustomWord `json:"words" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type AudioDetails struct {

	// The type of the audio resource:
	// * `audio` for an individual audio file
	// * `archive` for an archive (**.zip** or **.tar.gz**) file that contains audio files
	// * `undetermined` for a resource that the service cannot validate (for example, if the user mistakenly passes a file
	// that does not contain audio, such as a JPEG file).
	Type *string `json:"type,omitempty"`

	// **For an audio-type resource,** the codec in which the audio is encoded. Omitted for an archive-type resource.
	Codec *string `json:"codec,omitempty"`

	// **For an audio-type resource,** the sampling rate of the audio in Hertz (samples per second). Omitted for an
	// archive-type resource.
	Frequency *int64 `json:"frequency,omitempty"`

	// **For an archive-type resource,** the format of the compressed archive:
	// * `zip` for a **.zip** file
	// * `gzip` for a **.tar.gz** file
	//
	// Omitted for an audio-type resource.
	Compression *string `json:"compression,omitempty"`
}

type AudioListing struct {

	// **For an audio-type resource,**  the total seconds of audio in the resource. Omitted for an archive-type resource.
	Duration *int64 `json:"duration,omitempty"`

	// **For an audio-type resource,** the user-specified name of the resource. Omitted for an archive-type resource.
	Name *string `json:"name,omitempty"`

	// **For an audio-type resource,** an `AudioDetails` object that provides detailed information about the resource. The
	// object is empty until the service finishes processing the audio. Omitted for an archive-type resource.
	Details *AudioDetails `json:"details,omitempty"`

	// **For an audio-type resource,** the status of the resource:
	// * `ok`: The service successfully analyzed the audio data. The data can be used to train the custom model.
	// * `being_processed`: The service is still analyzing the audio data. The service cannot accept requests to add new
	// audio resources or to train the custom model until its analysis is complete.
	// * `invalid`: The audio data is not valid for training the custom model (possibly because it has the wrong format or
	// sampling rate, or because it is corrupted).
	//
	// Omitted for an archive-type resource.
	Status *string `json:"status,omitempty"`

	// **For an archive-type resource,** an object of type `AudioResource` that provides information about the resource.
	// Omitted for an audio-type resource.
	Container *AudioResource `json:"container,omitempty"`

	// **For an archive-type resource,** an array of `AudioResource` objects that provides information about the audio-type
	// resources that are contained in the resource. Omitted for an audio-type resource.
	Audio []AudioResource `json:"audio,omitempty"`
}

type AudioResource struct {

	// The total seconds of audio in the audio resource.
	Duration *int64 `json:"duration" validate:"required"`

	// **For an archive-type resource,** the user-specified name of the resource.
	//
	// **For an audio-type resource,** the user-specified name of the resource or the name of the audio file that the user
	// added for the resource. The value depends on the method that is called.
	Name *string `json:"name" validate:"required"`

	// An `AudioDetails` object that provides detailed information about the audio resource. The object is empty until the
	// service finishes processing the audio.
	Details *AudioDetails `json:"details" validate:"required"`

	// The status of the audio resource:
	// * `ok`: The service successfully analyzed the audio data. The data can be used to train the custom model.
	// * `being_processed`: The service is still analyzing the audio data. The service cannot accept requests to add new
	// audio resources or to train the custom model until its analysis is complete.
	// * `invalid`: The audio data is not valid for training the custom model (possibly because it has the wrong format or
	// sampling rate, or because it is corrupted). For an archive file, the entire archive is invalid if any of its audio
	// files are invalid.
	Status *string `json:"status" validate:"required"`
}

type AudioResources struct {

	// The total minutes of accumulated audio summed over all of the valid audio resources for the custom acoustic model.
	// You can use this value to determine whether the custom model has too little or too much audio to begin training.
	TotalMinutesOfAudio *float64 `json:"total_minutes_of_audio" validate:"required"`

	// An array of `AudioResource` objects that provides information about the audio resources of the custom acoustic
	// model. The array is empty if the custom model has no audio resources.
	Audio []AudioResource `json:"audio" validate:"required"`
}

type CheckJobOptions struct {

	// The identifier of the asynchronous job that is to be used for the request. You must make the request with
	// credentials for the instance of the service that owns the job.
	ID *string `json:"id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type CheckJobsOptions struct {

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type Corpora struct {

	// An array of `Corpus` objects that provides information about the corpora for the custom model. The array is empty if
	// the custom model has no corpora.
	Corpora []Corpus `json:"corpora" validate:"required"`
}

type Corpus struct {

	// The name of the corpus.
	Name *string `json:"name" validate:"required"`

	// The total number of words in the corpus. The value is `0` while the corpus is being processed.
	TotalWords *int64 `json:"total_words" validate:"required"`

	// The number of OOV words in the corpus. The value is `0` while the corpus is being processed.
	OutOfVocabularyWords *int64 `json:"out_of_vocabulary_words" validate:"required"`

	// The status of the corpus:
	// * `analyzed`: The service successfully analyzed the corpus. The custom model can be trained with data from the
	// corpus.
	// * `being_processed`: The service is still analyzing the corpus. The service cannot accept requests to add new
	// resources or to train the custom model.
	// * `undetermined`: The service encountered an error while processing the corpus. The `error` field describes the
	// failure.
	Status *string `json:"status" validate:"required"`

	// If the status of the corpus is `undetermined`, the following message: `Analysis of corpus 'name' failed. Please try
	// adding the corpus again by setting the 'allow_overwrite' flag to 'true'`.
	Error *string `json:"error,omitempty"`
}

type CreateAcousticModelOptions struct {

	// A user-defined name for the new custom acoustic model. Use a name that is unique among all custom acoustic models
	// that you own. Use a localized name that matches the language of the custom model. Use a name that describes the
	// acoustic environment of the custom model, such as `Mobile custom model` or `Noisy car custom model`.
	Name *string `json:"name" validate:"required"`

	// The name of the base language model that is to be customized by the new custom acoustic model. The new custom model
	// can be used only with the base model that it customizes.
	//
	// To determine whether a base model supports acoustic model customization, refer to [Language support for
	// customization](https://cloud.ibm.com/docs/services/speech-to-text/custom.html#languageSupport).
	BaseModelName *string `json:"base_model_name" validate:"required"`

	// A description of the new custom acoustic model. Use a localized description that matches the language of the custom
	// model.
	Description *string `json:"description,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type CreateJobOptions struct {

	// The audio to transcribe.
	Audio *io.ReadCloser `json:"audio" validate:"required"`

	// The identifier of the model that is to be used for the recognition request. See [Languages and
	// models](https://cloud.ibm.com/docs/services/speech-to-text/models.html).
	Model *string `json:"model,omitempty"`

	// A URL to which callback notifications are to be sent. The URL must already be successfully white-listed by using the
	// **Register a callback** method. You can include the same callback URL with any number of job creation requests. Omit
	// the parameter to poll the service for job completion and results.
	//
	// Use the `user_token` parameter to specify a unique user-specified string with each job to differentiate the callback
	// notifications for the jobs.
	CallbackURL *string `json:"callback_url,omitempty"`

	// If the job includes a callback URL, a comma-separated list of notification events to which to subscribe. Valid
	// events are
	// * `recognitions.started` generates a callback notification when the service begins to process the job.
	// * `recognitions.completed` generates a callback notification when the job is complete. You must use the **Check a
	// job** method to retrieve the results before they time out or are deleted.
	// * `recognitions.completed_with_results` generates a callback notification when the job is complete. The notification
	// includes the results of the request.
	// * `recognitions.failed` generates a callback notification if the service experiences an error while processing the
	// job.
	//
	// The `recognitions.completed` and `recognitions.completed_with_results` events are incompatible. You can specify only
	// of the two events.
	//
	// If the job includes a callback URL, omit the parameter to subscribe to the default events: `recognitions.started`,
	// `recognitions.completed`, and `recognitions.failed`. If the job does not include a callback URL, omit the parameter.
	Events *string `json:"events,omitempty"`

	// If the job includes a callback URL, a user-specified string that the service is to include with each callback
	// notification for the job; the token allows the user to maintain an internal mapping between jobs and notification
	// events. If the job does not include a callback URL, omit the parameter.
	UserToken *string `json:"user_token,omitempty"`

	// The number of minutes for which the results are to be available after the job has finished. If not delivered via a
	// callback, the results must be retrieved within this time. Omit the parameter to use a time to live of one week. The
	// parameter is valid with or without a callback URL.
	ResultsTTL *int64 `json:"results_ttl,omitempty"`

	// The customization ID (GUID) of a custom language model that is to be used with the recognition request. The base
	// model of the specified custom language model must match the model specified with the `model` parameter. You must
	// make the request with credentials for the instance of the service that owns the custom model. By default, no custom
	// language model is used. See [Custom
	// models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	//
	// **Note:** Use this parameter instead of the deprecated `customization_id` parameter.
	LanguageCustomizationID *string `json:"language_customization_id,omitempty"`

	// The customization ID (GUID) of a custom acoustic model that is to be used with the recognition request. The base
	// model of the specified custom acoustic model must match the model specified with the `model` parameter. You must
	// make the request with credentials for the instance of the service that owns the custom model. By default, no custom
	// acoustic model is used. See [Custom
	// models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	AcousticCustomizationID *string `json:"acoustic_customization_id,omitempty"`

	// The version of the specified base model that is to be used with recognition request. Multiple versions of a base
	// model can exist when a model is updated for internal improvements. The parameter is intended primarily for use with
	// custom models that have been upgraded for a new base model. The default value depends on whether the parameter is
	// used with or without a custom model. See [Base model
	// version](https://cloud.ibm.com/docs/services/speech-to-text/input.html#version).
	BaseModelVersion *string `json:"base_model_version,omitempty"`

	// If you specify the customization ID (GUID) of a custom language model with the recognition request, the
	// customization weight tells the service how much weight to give to words from the custom language model compared to
	// those from the base model for the current request.
	//
	// Specify a value between 0.0 and 1.0. Unless a different customization weight was specified for the custom model when
	// it was trained, the default value is 0.3. A customization weight that you specify overrides a weight that was
	// specified when the custom model was trained.
	//
	// The default value yields the best performance in general. Assign a higher value if your audio makes frequent use of
	// OOV words from the custom model. Use caution when setting the weight: a higher value can improve the accuracy of
	// phrases from the custom model's domain, but it can negatively affect performance on non-domain phrases.
	//
	// See [Custom models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	CustomizationWeight *float64 `json:"customization_weight,omitempty"`

	// The time in seconds after which, if only silence (no speech) is detected in streaming audio, the connection is
	// closed with a 400 error. The parameter is useful for stopping audio submission from a live microphone when a user
	// simply walks away. Use `-1` for infinity. See [Inactivity
	// timeout](https://cloud.ibm.com/docs/services/speech-to-text/input.html#timeouts-inactivity).
	InactivityTimeout *int64 `json:"inactivity_timeout,omitempty"`

	// An array of keyword strings to spot in the audio. Each keyword string can include one or more string tokens.
	// Keywords are spotted only in the final results, not in interim hypotheses. If you specify any keywords, you must
	// also specify a keywords threshold. You can spot a maximum of 1000 keywords. Omit the parameter or specify an empty
	// array if you do not need to spot keywords. See [Keyword
	// spotting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#keyword_spotting).
	Keywords []string `json:"keywords,omitempty"`

	// A confidence value that is the lower bound for spotting a keyword. A word is considered to match a keyword if its
	// confidence is greater than or equal to the threshold. Specify a probability between 0.0 and 1.0. If you specify a
	// threshold, you must also specify one or more keywords. The service performs no keyword spotting if you omit either
	// parameter. See [Keyword spotting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#keyword_spotting).
	KeywordsThreshold *float32 `json:"keywords_threshold,omitempty"`

	// The maximum number of alternative transcripts that the service is to return. By default, the service returns a
	// single transcript. If you specify a value of `0`, the service uses the default value, `1`. See [Maximum
	// alternatives](https://cloud.ibm.com/docs/services/speech-to-text/output.html#max_alternatives).
	MaxAlternatives *int64 `json:"max_alternatives,omitempty"`

	// A confidence value that is the lower bound for identifying a hypothesis as a possible word alternative (also known
	// as "Confusion Networks"). An alternative word is considered if its confidence is greater than or equal to the
	// threshold. Specify a probability between 0.0 and 1.0. By default, the service computes no alternative words. See
	// [Word alternatives](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_alternatives).
	WordAlternativesThreshold *float32 `json:"word_alternatives_threshold,omitempty"`

	// If `true`, the service returns a confidence measure in the range of 0.0 to 1.0 for each word. By default, the
	// service returns no word confidence scores. See [Word
	// confidence](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_confidence).
	WordConfidence *bool `json:"word_confidence,omitempty"`

	// If `true`, the service returns time alignment for each word. By default, no timestamps are returned. See [Word
	// timestamps](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_timestamps).
	Timestamps *bool `json:"timestamps,omitempty"`

	// If `true`, the service filters profanity from all output except for keyword results by replacing inappropriate words
	// with a series of asterisks. Set the parameter to `false` to return results with no censoring. Applies to US English
	// transcription only. See [Profanity
	// filtering](https://cloud.ibm.com/docs/services/speech-to-text/output.html#profanity_filter).
	ProfanityFilter *bool `json:"profanity_filter,omitempty"`

	// If `true`, the service converts dates, times, series of digits and numbers, phone numbers, currency values, and
	// internet addresses into more readable, conventional representations in the final transcript of a recognition
	// request. For US English, the service also converts certain keyword strings to punctuation symbols. By default, the
	// service performs no smart formatting.
	//
	// **Note:** Applies to US English, Japanese, and Spanish transcription only.
	//
	// See [Smart formatting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#smart_formatting).
	SmartFormatting *bool `json:"smart_formatting,omitempty"`

	// If `true`, the response includes labels that identify which words were spoken by which participants in a
	// multi-person exchange. By default, the service returns no speaker labels. Setting `speaker_labels` to `true` forces
	// the `timestamps` parameter to be `true`, regardless of whether you specify `false` for the parameter.
	//
	// **Note:** Applies to US English, Japanese, and Spanish transcription only. To determine whether a language model
	// supports speaker labels, you can also use the **Get a model** method and check that the attribute `speaker_labels`
	// is set to `true`.
	//
	// See [Speaker labels](https://cloud.ibm.com/docs/services/speech-to-text/output.html#speaker_labels).
	SpeakerLabels *bool `json:"speaker_labels,omitempty"`

	// **Deprecated.** Use the `language_customization_id` parameter to specify the customization ID (GUID) of a custom
	// language model that is to be used with the recognition request. Do not specify both parameters with a request.
	CustomizationID *string `json:"customization_id,omitempty"`

	// The name of a grammar that is to be used with the recognition request. If you specify a grammar, you must also use
	// the `language_customization_id` parameter to specify the name of the custom language model for which the grammar is
	// defined. The service recognizes only strings that are recognized by the specified grammar; it does not recognize
	// other custom words from the model's words resource. See
	// [Grammars](https://cloud.ibm.com/docs/services/speech-to-text/input.html#grammars-input).
	GrammarName *string `json:"grammar_name,omitempty"`

	// If `true`, the service redacts, or masks, numeric data from final transcripts. The feature redacts any number that
	// has three or more consecutive digits by replacing each digit with an `X` character. It is intended to redact
	// sensitive numeric data, such as credit card numbers. By default, the service performs no redaction.
	//
	// When you enable redaction, the service automatically enables smart formatting, regardless of whether you explicitly
	// disable that feature. To ensure maximum security, the service also disables keyword spotting (ignores the `keywords`
	// and `keywords_threshold` parameters) and returns only a single final transcript (forces the `max_alternatives`
	// parameter to be `1`).
	//
	// **Note:** Applies to US English, Japanese, and Korean transcription only.
	//
	// See [Numeric redaction](https://cloud.ibm.com/docs/services/speech-to-text/output.html#redaction).
	Redaction *bool `json:"redaction,omitempty"`

	// The format (MIME type) of the audio. For more information about specifying an audio format, see **Audio formats
	// (content types)** in the method description.
	ContentType *string `json:"Content-Type,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type CreateLanguageModelOptions struct {

	// A user-defined name for the new custom language model. Use a name that is unique among all custom language models
	// that you own. Use a localized name that matches the language of the custom model. Use a name that describes the
	// domain of the custom model, such as `Medical custom model` or `Legal custom model`.
	Name *string `json:"name" validate:"required"`

	// The name of the base language model that is to be customized by the new custom language model. The new custom model
	// can be used only with the base model that it customizes.
	//
	// To determine whether a base model supports language model customization, use the **Get a model** method and check
	// that the attribute `custom_language_model` is set to `true`. You can also refer to [Language support for
	// customization](https://cloud.ibm.com/docs/services/speech-to-text/custom.html#languageSupport).
	BaseModelName *string `json:"base_model_name" validate:"required"`

	// The dialect of the specified language that is to be used with the custom language model. The parameter is meaningful
	// only for Spanish models, for which the service creates a custom language model that is suited for speech in one of
	// the following dialects:
	// * `es-ES` for Castilian Spanish (the default)
	// * `es-LA` for Latin American Spanish
	// * `es-US` for North American (Mexican) Spanish
	//
	// A specified dialect must be valid for the base model. By default, the dialect matches the language of the base
	// model; for example, `en-US` for either of the US English language models.
	Dialect *string `json:"dialect,omitempty"`

	// A description of the new custom language model. Use a localized description that matches the language of the custom
	// model.
	Description *string `json:"description,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type CustomWord struct {

	// For the **Add custom words** method, you must specify the custom word that is to be added to or updated in the
	// custom model. Do not include spaces in the word. Use a `-` (dash) or `_` (underscore) to connect the tokens of
	// compound words.
	//
	// Omit this parameter for the **Add a custom word** method.
	Word *string `json:"word,omitempty"`

	// An array of sounds-like pronunciations for the custom word. Specify how words that are difficult to pronounce,
	// foreign words, acronyms, and so on can be pronounced by users.
	// * For a word that is not in the service's base vocabulary, omit the parameter to have the service automatically
	// generate a sounds-like pronunciation for the word.
	// * For a word that is in the service's base vocabulary, use the parameter to specify additional pronunciations for
	// the word. You cannot override the default pronunciation of a word; pronunciations you add augment the pronunciation
	// from the base vocabulary.
	//
	// A word can have at most five sounds-like pronunciations. A pronunciation can include at most 40 characters not
	// including spaces.
	SoundsLike []string `json:"sounds_like,omitempty"`

	// An alternative spelling for the custom word when it appears in a transcript. Use the parameter when you want the
	// word to have a spelling that is different from its usual representation or from its spelling in corpora training
	// data.
	DisplayAs *string `json:"display_as,omitempty"`
}

type DeleteAcousticModelOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteAudioOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the audio resource for the custom acoustic model.
	AudioName *string `json:"audio_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteCorpusOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the corpus for the custom language model.
	CorpusName *string `json:"corpus_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteGrammarOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the grammar for the custom language model.
	GrammarName *string `json:"grammar_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteJobOptions struct {

	// The identifier of the asynchronous job that is to be used for the request. You must make the request with
	// credentials for the instance of the service that owns the job.
	ID *string `json:"id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteLanguageModelOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteUserDataOptions struct {

	// The customer ID for which all data is to be deleted.
	CustomerID *string `json:"customer_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type DeleteWordOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The custom word that is to be deleted from the custom language model. URL-encode the word if it includes non-ASCII
	// characters. For more information, see [Character
	// encoding](https://cloud.ibm.com/docs/services/speech-to-text/language-resource.html#charEncoding).
	WordName *string `json:"word_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetAcousticModelOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetAudioOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the audio resource for the custom acoustic model.
	AudioName *string `json:"audio_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetCorpusOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the corpus for the custom language model.
	CorpusName *string `json:"corpus_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetGrammarOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The name of the grammar for the custom language model.
	GrammarName *string `json:"grammar_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetLanguageModelOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetModelOptions struct {

	// The identifier of the model in the form of its name from the output of the **Get a model** method.
	ModelID *string `json:"model_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type GetWordOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The custom word that is to be read from the custom language model. URL-encode the word if it includes non-ASCII
	// characters. For more information, see [Character
	// encoding](https://cloud.ibm.com/docs/services/speech-to-text/language-resource.html#charEncoding).
	WordName *string `json:"word_name" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type Grammar struct {

	// The name of the grammar.
	Name *string `json:"name" validate:"required"`

	// The number of OOV words in the grammar. The value is `0` while the grammar is being processed.
	OutOfVocabularyWords *int64 `json:"out_of_vocabulary_words" validate:"required"`

	// The status of the grammar:
	// * `analyzed`: The service successfully analyzed the grammar. The custom model can be trained with data from the
	// grammar.
	// * `being_processed`: The service is still analyzing the grammar. The service cannot accept requests to add new
	// resources or to train the custom model.
	// * `undetermined`: The service encountered an error while processing the grammar. The `error` field describes the
	// failure.
	Status *string `json:"status" validate:"required"`

	// If the status of the grammar is `undetermined`, the following message: `Analysis of grammar '{grammar_name}' failed.
	// Please try fixing the error or adding the grammar again by setting the 'allow_overwrite' flag to 'true'.`.
	Error *string `json:"error,omitempty"`
}

type Grammars struct {

	// An array of `Grammar` objects that provides information about the grammars for the custom model. The array is empty
	// if the custom model has no grammars.
	Grammars []Grammar `json:"grammars" validate:"required"`
}

type KeywordResult struct {

	// A specified keyword normalized to the spoken phrase that matched in the audio input.
	NormalizedText *string `json:"normalized_text" validate:"required"`

	// The start time in seconds of the keyword match.
	StartTime *float64 `json:"start_time" validate:"required"`

	// The end time in seconds of the keyword match.
	EndTime *float64 `json:"end_time" validate:"required"`

	// A confidence score for the keyword match in the range of 0.0 to 1.0.
	Confidence *float64 `json:"confidence" validate:"required"`
}

type LanguageModel struct {

	// The customization ID (GUID) of the custom language model. The **Create a custom language model** method returns only
	// this field of the object; it does not return the other fields.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The date and time in Coordinated Universal Time (UTC) at which the custom language model was created. The value is
	// provided in full ISO 8601 format (`YYYY-MM-DDThh:mm:ss.sTZD`).
	Created *string `json:"created,omitempty"`

	// The language identifier of the custom language model (for example, `en-US`).
	Language *string `json:"language,omitempty"`

	// The dialect of the language for the custom language model. By default, the dialect matches the language of the base
	// model; for example, `en-US` for either of the US English language models. For Spanish models, the field indicates
	// the dialect for which the model was created:
	// * `es-ES` for Castilian Spanish (the default)
	// * `es-LA` for Latin American Spanish
	// * `es-US` for North American (Mexican) Spanish.
	Dialect *string `json:"dialect,omitempty"`

	// A list of the available versions of the custom language model. Each element of the array indicates a version of the
	// base model with which the custom model can be used. Multiple versions exist only if the custom model has been
	// upgraded; otherwise, only a single version is shown.
	Versions []string `json:"versions,omitempty"`

	// The GUID of the credentials for the instance of the service that owns the custom language model.
	Owner *string `json:"owner,omitempty"`

	// The name of the custom language model.
	Name *string `json:"name,omitempty"`

	// The description of the custom language model.
	Description *string `json:"description,omitempty"`

	// The name of the language model for which the custom language model was created.
	BaseModelName *string `json:"base_model_name,omitempty"`

	// The current status of the custom language model:
	// * `pending`: The model was created but is waiting either for training data to be added or for the service to finish
	// analyzing added data.
	// * `ready`: The model contains data and is ready to be trained.
	// * `training`: The model is currently being trained.
	// * `available`: The model is trained and ready to use.
	// * `upgrading`: The model is currently being upgraded.
	// * `failed`: Training of the model failed.
	Status *string `json:"status,omitempty"`

	// A percentage that indicates the progress of the custom language model's current training. A value of `100` means
	// that the model is fully trained. **Note:** The `progress` field does not currently reflect the progress of the
	// training. The field changes from `0` to `100` when training is complete.
	Progress *int64 `json:"progress,omitempty"`

	// If an error occurred while adding a grammar file to the custom language model, a message that describes an `Internal
	// Server Error` and includes the string `Cannot compile grammar`. The status of the custom model is not affected by
	// the error, but the grammar cannot be used with the model.
	Error *string `json:"error,omitempty"`

	// If the request included unknown parameters, the following message: `Unexpected query parameter(s) ['parameters']
	// detected`, where `parameters` is a list that includes a quoted string for each unknown parameter.
	Warnings *string `json:"warnings,omitempty"`
}

type LanguageModels struct {

	// An array of `LanguageModel` objects that provides information about each available custom language model. The array
	// is empty if the requesting credentials own no custom language models (if no language is specified) or own no custom
	// language models for the specified language.
	Customizations []LanguageModel `json:"customizations" validate:"required"`
}

type ListAcousticModelsOptions struct {

	// The identifier of the language for which custom language or custom acoustic models are to be returned (for example,
	// `en-US`). Omit the parameter to see all custom language or custom acoustic models that are owned by the requesting
	// credentials.
	Language *string `json:"language,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListAudioOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListCorporaOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListGrammarsOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListLanguageModelsOptions struct {

	// The identifier of the language for which custom language or custom acoustic models are to be returned (for example,
	// `en-US`). Omit the parameter to see all custom language or custom acoustic models that are owned by the requesting
	// credentials.
	Language *string `json:"language,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListModelsOptions struct {

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ListWordsOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The type of words to be listed from the custom language model's words resource:
	// * `all` (the default) shows all words.
	// * `user` shows only custom words that were added or modified by the user directly.
	// * `corpora` shows only OOV that were extracted from corpora.
	// * `grammars` shows only OOV words that are recognized by grammars.
	WordType *string `json:"word_type,omitempty"`

	// Indicates the order in which the words are to be listed, `alphabetical` or by `count`. You can prepend an optional
	// `+` or `-` to an argument to indicate whether the results are to be sorted in ascending or descending order. By
	// default, words are sorted in ascending alphabetical order. For alphabetical ordering, the lexicographical precedence
	// is numeric values, uppercase letters, and lowercase letters. For count ordering, values with the same count are
	// ordered alphabetically. With the `curl` command, URL encode the `+` symbol as `%2B`.
	Sort *string `json:"sort,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type RecognitionJob struct {

	// The ID of the asynchronous job.
	ID *string `json:"id" validate:"required"`

	// The current status of the job:
	// * `waiting`: The service is preparing the job for processing. The service returns this status when the job is
	// initially created or when it is waiting for capacity to process the job. The job remains in this state until the
	// service has the capacity to begin processing it.
	// * `processing`: The service is actively processing the job.
	// * `completed`: The service has finished processing the job. If the job specified a callback URL and the event
	// `recognitions.completed_with_results`, the service sent the results with the callback notification. Otherwise, you
	// must retrieve the results by checking the individual job.
	// * `failed`: The job failed.
	Status *string `json:"status" validate:"required"`

	// The date and time in Coordinated Universal Time (UTC) at which the job was created. The value is provided in full
	// ISO 8601 format (`YYYY-MM-DDThh:mm:ss.sTZD`).
	Created *string `json:"created" validate:"required"`

	// The date and time in Coordinated Universal Time (UTC) at which the job was last updated by the service. The value is
	// provided in full ISO 8601 format (`YYYY-MM-DDThh:mm:ss.sTZD`). This field is returned only by the **Check jobs** and
	// **Check a job** methods.
	Updated *string `json:"updated,omitempty"`

	// The URL to use to request information about the job with the **Check a job** method. This field is returned only by
	// the **Create a job** method.
	URL *string `json:"url,omitempty"`

	// The user token associated with a job that was created with a callback URL and a user token. This field can be
	// returned only by the **Check jobs** method.
	UserToken *string `json:"user_token,omitempty"`

	// If the status is `completed`, the results of the recognition request as an array that includes a single instance of
	// a `SpeechRecognitionResults` object. This field is returned only by the **Check a job** method.
	Results []SpeechRecognitionResults `json:"results,omitempty"`

	// An array of warning messages about invalid parameters included with the request. Each warning includes a descriptive
	// message and a list of invalid argument strings, for example, `"unexpected query parameter 'user_token', query
	// parameter 'callback_url' was not specified"`. The request succeeds despite the warnings. This field can be returned
	// only by the **Create a job** method.
	Warnings []string `json:"warnings,omitempty"`
}

type RecognitionJobs struct {

	// An array of `RecognitionJob` objects that provides the status for each of the user's current jobs. The array is
	// empty if the user has no current jobs.
	Recognitions []RecognitionJob `json:"recognitions" validate:"required"`
}

type RecognizeCallbackWrapper interface {
	OnOpen()
	OnClose()
	OnData(*core.DetailedResponse)
	OnError(error)
}

type RecognizeListener struct {
	IsClosed chan bool
	Callback RecognizeCallbackWrapper
}

type RecognizeOptions struct {

	// The audio to transcribe.
	Audio *io.ReadCloser `json:"audio" validate:"required"`

	// The identifier of the model that is to be used for the recognition request. See [Languages and
	// models](https://cloud.ibm.com/docs/services/speech-to-text/models.html).
	Model *string `json:"model,omitempty"`

	// The customization ID (GUID) of a custom language model that is to be used with the recognition request. The base
	// model of the specified custom language model must match the model specified with the `model` parameter. You must
	// make the request with credentials for the instance of the service that owns the custom model. By default, no custom
	// language model is used. See [Custom
	// models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	//
	// **Note:** Use this parameter instead of the deprecated `customization_id` parameter.
	LanguageCustomizationID *string `json:"language_customization_id,omitempty"`

	// The customization ID (GUID) of a custom acoustic model that is to be used with the recognition request. The base
	// model of the specified custom acoustic model must match the model specified with the `model` parameter. You must
	// make the request with credentials for the instance of the service that owns the custom model. By default, no custom
	// acoustic model is used. See [Custom
	// models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	AcousticCustomizationID *string `json:"acoustic_customization_id,omitempty"`

	// The version of the specified base model that is to be used with recognition request. Multiple versions of a base
	// model can exist when a model is updated for internal improvements. The parameter is intended primarily for use with
	// custom models that have been upgraded for a new base model. The default value depends on whether the parameter is
	// used with or without a custom model. See [Base model
	// version](https://cloud.ibm.com/docs/services/speech-to-text/input.html#version).
	BaseModelVersion *string `json:"base_model_version,omitempty"`

	// If you specify the customization ID (GUID) of a custom language model with the recognition request, the
	// customization weight tells the service how much weight to give to words from the custom language model compared to
	// those from the base model for the current request.
	//
	// Specify a value between 0.0 and 1.0. Unless a different customization weight was specified for the custom model when
	// it was trained, the default value is 0.3. A customization weight that you specify overrides a weight that was
	// specified when the custom model was trained.
	//
	// The default value yields the best performance in general. Assign a higher value if your audio makes frequent use of
	// OOV words from the custom model. Use caution when setting the weight: a higher value can improve the accuracy of
	// phrases from the custom model's domain, but it can negatively affect performance on non-domain phrases.
	//
	// See [Custom models](https://cloud.ibm.com/docs/services/speech-to-text/input.html#custom-input).
	CustomizationWeight *float64 `json:"customization_weight,omitempty"`

	// The time in seconds after which, if only silence (no speech) is detected in streaming audio, the connection is
	// closed with a 400 error. The parameter is useful for stopping audio submission from a live microphone when a user
	// simply walks away. Use `-1` for infinity. See [Inactivity
	// timeout](https://cloud.ibm.com/docs/services/speech-to-text/input.html#timeouts-inactivity).
	InactivityTimeout *int64 `json:"inactivity_timeout,omitempty"`

	// An array of keyword strings to spot in the audio. Each keyword string can include one or more string tokens.
	// Keywords are spotted only in the final results, not in interim hypotheses. If you specify any keywords, you must
	// also specify a keywords threshold. You can spot a maximum of 1000 keywords. Omit the parameter or specify an empty
	// array if you do not need to spot keywords. See [Keyword
	// spotting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#keyword_spotting).
	Keywords []string `json:"keywords,omitempty"`

	// A confidence value that is the lower bound for spotting a keyword. A word is considered to match a keyword if its
	// confidence is greater than or equal to the threshold. Specify a probability between 0.0 and 1.0. If you specify a
	// threshold, you must also specify one or more keywords. The service performs no keyword spotting if you omit either
	// parameter. See [Keyword spotting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#keyword_spotting).
	KeywordsThreshold *float32 `json:"keywords_threshold,omitempty"`

	// The maximum number of alternative transcripts that the service is to return. By default, the service returns a
	// single transcript. If you specify a value of `0`, the service uses the default value, `1`. See [Maximum
	// alternatives](https://cloud.ibm.com/docs/services/speech-to-text/output.html#max_alternatives).
	MaxAlternatives *int64 `json:"max_alternatives,omitempty"`

	// A confidence value that is the lower bound for identifying a hypothesis as a possible word alternative (also known
	// as "Confusion Networks"). An alternative word is considered if its confidence is greater than or equal to the
	// threshold. Specify a probability between 0.0 and 1.0. By default, the service computes no alternative words. See
	// [Word alternatives](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_alternatives).
	WordAlternativesThreshold *float32 `json:"word_alternatives_threshold,omitempty"`

	// If `true`, the service returns a confidence measure in the range of 0.0 to 1.0 for each word. By default, the
	// service returns no word confidence scores. See [Word
	// confidence](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_confidence).
	WordConfidence *bool `json:"word_confidence,omitempty"`

	// If `true`, the service returns time alignment for each word. By default, no timestamps are returned. See [Word
	// timestamps](https://cloud.ibm.com/docs/services/speech-to-text/output.html#word_timestamps).
	Timestamps *bool `json:"timestamps,omitempty"`

	// If `true`, the service filters profanity from all output except for keyword results by replacing inappropriate words
	// with a series of asterisks. Set the parameter to `false` to return results with no censoring. Applies to US English
	// transcription only. See [Profanity
	// filtering](https://cloud.ibm.com/docs/services/speech-to-text/output.html#profanity_filter).
	ProfanityFilter *bool `json:"profanity_filter,omitempty"`

	// If `true`, the service converts dates, times, series of digits and numbers, phone numbers, currency values, and
	// internet addresses into more readable, conventional representations in the final transcript of a recognition
	// request. For US English, the service also converts certain keyword strings to punctuation symbols. By default, the
	// service performs no smart formatting.
	//
	// **Note:** Applies to US English, Japanese, and Spanish transcription only.
	//
	// See [Smart formatting](https://cloud.ibm.com/docs/services/speech-to-text/output.html#smart_formatting).
	SmartFormatting *bool `json:"smart_formatting,omitempty"`

	// If `true`, the response includes labels that identify which words were spoken by which participants in a
	// multi-person exchange. By default, the service returns no speaker labels. Setting `speaker_labels` to `true` forces
	// the `timestamps` parameter to be `true`, regardless of whether you specify `false` for the parameter.
	//
	// **Note:** Applies to US English, Japanese, and Spanish transcription only. To determine whether a language model
	// supports speaker labels, you can also use the **Get a model** method and check that the attribute `speaker_labels`
	// is set to `true`.
	//
	// See [Speaker labels](https://cloud.ibm.com/docs/services/speech-to-text/output.html#speaker_labels).
	SpeakerLabels *bool `json:"speaker_labels,omitempty"`

	// **Deprecated.** Use the `language_customization_id` parameter to specify the customization ID (GUID) of a custom
	// language model that is to be used with the recognition request. Do not specify both parameters with a request.
	CustomizationID *string `json:"customization_id,omitempty"`

	// The name of a grammar that is to be used with the recognition request. If you specify a grammar, you must also use
	// the `language_customization_id` parameter to specify the name of the custom language model for which the grammar is
	// defined. The service recognizes only strings that are recognized by the specified grammar; it does not recognize
	// other custom words from the model's words resource. See
	// [Grammars](https://cloud.ibm.com/docs/services/speech-to-text/input.html#grammars-input).
	GrammarName *string `json:"grammar_name,omitempty"`

	// If `true`, the service redacts, or masks, numeric data from final transcripts. The feature redacts any number that
	// has three or more consecutive digits by replacing each digit with an `X` character. It is intended to redact
	// sensitive numeric data, such as credit card numbers. By default, the service performs no redaction.
	//
	// When you enable redaction, the service automatically enables smart formatting, regardless of whether you explicitly
	// disable that feature. To ensure maximum security, the service also disables keyword spotting (ignores the `keywords`
	// and `keywords_threshold` parameters) and returns only a single final transcript (forces the `max_alternatives`
	// parameter to be `1`).
	//
	// **Note:** Applies to US English, Japanese, and Korean transcription only.
	//
	// See [Numeric redaction](https://cloud.ibm.com/docs/services/speech-to-text/output.html#redaction).
	Redaction *bool `json:"redaction,omitempty"`

	// The format (MIME type) of the audio. For more information about specifying an audio format, see **Audio formats
	// (content types)** in the method description.
	ContentType *string `json:"Content-Type,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type RecognizeUsingWebsocketOptions struct {
	RecognizeOptions

	// Action that is to be performed. Allowable values: start, stop
	Action *string `json:"action,omitempty"`

	// If true, the service returns interim results as a stream of JSON SpeechRecognitionResults objects.
	// If false, the service returns a single SpeechRecognitionResults object with final results only.
	InterimResults *bool `json:"interim_results,omitempty"`
}

type RegisterCallbackOptions struct {

	// An HTTP or HTTPS URL to which callback notifications are to be sent. To be white-listed, the URL must successfully
	// echo the challenge string during URL verification. During verification, the client can also check the signature that
	// the service sends in the `X-Callback-Signature` header to verify the origin of the request.
	CallbackURL *string `json:"callback_url" validate:"required"`

	// A user-specified string that the service uses to generate the HMAC-SHA1 signature that it sends via the
	// `X-Callback-Signature` header. The service includes the header during URL verification and with every notification
	// sent to the callback URL. It calculates the signature over the payload of the notification. If you omit the
	// parameter, the service does not send the header.
	UserSecret *string `json:"user_secret,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type RegisterStatus struct {

	// The current status of the job:
	// * `created`: The service successfully white-listed the callback URL as a result of the call.
	// * `already created`: The URL was already white-listed.
	Status *string `json:"status" validate:"required"`

	// The callback URL that is successfully registered.
	URL *string `json:"url" validate:"required"`
}

type ResetAcousticModelOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type ResetLanguageModelOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type SpeakerLabelsResult struct {

	// The start time of a word from the transcript. The value matches the start time of a word from the `timestamps`
	// array.
	From *float32 `json:"from" validate:"required"`

	// The end time of a word from the transcript. The value matches the end time of a word from the `timestamps` array.
	To *float32 `json:"to" validate:"required"`

	// The numeric identifier that the service assigns to a speaker from the audio. Speaker IDs begin at `0` initially but
	// can evolve and change across interim results (if supported by the method) and between interim and final results as
	// the service processes the audio. They are not guaranteed to be sequential, contiguous, or ordered.
	Speaker *int64 `json:"speaker" validate:"required"`

	// A score that indicates the service's confidence in its identification of the speaker in the range of 0.0 to 1.0.
	Confidence *float32 `json:"confidence" validate:"required"`

	// An indication of whether the service might further change word and speaker-label results. A value of `true` means
	// that the service guarantees not to send any further updates for the current or any preceding results; `false` means
	// that the service might send further updates to the results.
	FinalResults *bool `json:"final" validate:"required"`
}

type SpeechModel struct {

	// The name of the model for use as an identifier in calls to the service (for example, `en-US_BroadbandModel`).
	Name *string `json:"name" validate:"required"`

	// The language identifier of the model (for example, `en-US`).
	Language *string `json:"language" validate:"required"`

	// The sampling rate (minimum acceptable rate for audio) used by the model in Hertz.
	Rate *int64 `json:"rate" validate:"required"`

	// The URI for the model.
	URL *string `json:"url" validate:"required"`

	// Describes the additional service features that are supported with the model.
	SupportedFeatures *SupportedFeatures `json:"supported_features" validate:"required"`

	// A brief description of the model.
	Description *string `json:"description" validate:"required"`
}

type SpeechModels struct {

	// An array of `SpeechModel` objects that provides information about each available model.
	Models []SpeechModel `json:"models" validate:"required"`
}

type SpeechRecognitionAlternative struct {

	// A transcription of the audio.
	Transcript *string `json:"transcript" validate:"required"`

	// A score that indicates the service's confidence in the transcript in the range of 0.0 to 1.0. A confidence score is
	// returned only for the best alternative and only with results marked as final.
	Confidence *float64 `json:"confidence,omitempty"`

	// Time alignments for each word from the transcript as a list of lists. Each inner list consists of three elements:
	// the word followed by its start and end time in seconds, for example: `[["hello",0.0,1.2],["world",1.2,2.5]]`.
	// Timestamps are returned only for the best alternative.
	Timestamps []interface{} `json:"timestamps,omitempty"`

	// A confidence score for each word of the transcript as a list of lists. Each inner list consists of two elements: the
	// word and its confidence score in the range of 0.0 to 1.0, for example: `[["hello",0.95],["world",0.866]]`.
	// Confidence scores are returned only for the best alternative and only with results marked as final.
	WordConfidence []interface{} `json:"word_confidence,omitempty"`
}

type SpeechRecognitionResult struct {

	// An indication of whether the transcription results are final. If `true`, the results for this utterance are not
	// updated further; no additional results are sent for a `result_index` once its results are indicated as final.
	FinalResults *bool `json:"final" validate:"required"`

	// An array of alternative transcripts. The `alternatives` array can include additional requested output such as word
	// confidence or timestamps.
	Alternatives []SpeechRecognitionAlternative `json:"alternatives" validate:"required"`

	// A dictionary (or associative array) whose keys are the strings specified for `keywords` if both that parameter and
	// `keywords_threshold` are specified. The value for each key is an array of matches spotted in the audio for that
	// keyword. Each match is described by a `KeywordResult` object. A keyword for which no matches are found is omitted
	// from the dictionary. The dictionary is omitted entirely if no matches are found for any keywords.
	KeywordsResult map[string][]KeywordResult `json:"keywords_result,omitempty"`

	// An array of alternative hypotheses found for words of the input audio if a `word_alternatives_threshold` is
	// specified.
	WordAlternatives []WordAlternativeResults `json:"word_alternatives,omitempty"`
}

type SpeechRecognitionResults struct {

	// An array of `SpeechRecognitionResult` objects that can include interim and final results (interim results are
	// returned only if supported by the method). Final results are guaranteed not to change; interim results might be
	// replaced by further interim results and final results. The service periodically sends updates to the results list;
	// the `result_index` is set to the lowest index in the array that has changed; it is incremented for new results.
	Results []SpeechRecognitionResult `json:"results,omitempty"`

	// An index that indicates a change point in the `results` array. The service increments the index only for additional
	// results that it sends for new audio for the same request.
	ResultIndex *int64 `json:"result_index,omitempty"`

	// An array of `SpeakerLabelsResult` objects that identifies which words were spoken by which speakers in a
	// multi-person exchange. The array is returned only if the `speaker_labels` parameter is `true`. When interim results
	// are also requested for methods that support them, it is possible for a `SpeechRecognitionResults` object to include
	// only the `speaker_labels` field.
	SpeakerLabels []SpeakerLabelsResult `json:"speaker_labels,omitempty"`

	// An array of warning messages associated with the request:
	// * Warnings for invalid parameters or fields can include a descriptive message and a list of invalid argument
	// strings, for example, `"Unknown arguments:"` or `"Unknown url query arguments:"` followed by a list of the form
	// `"{invalid_arg_1}, {invalid_arg_2}."`
	// * The following warning is returned if the request passes a custom model that is based on an older version of a base
	// model for which an updated version is available: `"Using previous version of base model, because your custom model
	// has been built with it. Please note that this version will be supported only for a limited time. Consider updating
	// your custom model to the new base model. If you do not do that you will be automatically switched to base model when
	// you used the non-updated custom model."`
	//
	// In both cases, the request succeeds despite the warnings.
	Warnings []string `json:"warnings,omitempty"`
}

type SpeechToTextV1 struct {
	Service *core.BaseService
}

type SpeechToTextV1Options struct {
	URL            string
	Username       string
	Password       string
	IAMApiKey      string
	IAMAccessToken string
	IAMURL         string
}

type SupportedFeatures struct {

	// Indicates whether the customization interface can be used to create a custom language model based on the language
	// model.
	CustomLanguageModel *bool `json:"custom_language_model" validate:"required"`

	// Indicates whether the `speaker_labels` parameter can be used with the language model.
	SpeakerLabels *bool `json:"speaker_labels" validate:"required"`
}

type TrainAcousticModelOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The customization ID (GUID) of a custom language model that is to be used during training of the custom acoustic
	// model. Specify a custom language model that has been trained with verbatim transcriptions of the audio resources or
	// that contains words that are relevant to the contents of the audio resources. The custom language model must be
	// based on the same version of the same base model as the custom acoustic model. The credentials specified with the
	// request must own both custom models.
	CustomLanguageModelID *string `json:"custom_language_model_id,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type TrainLanguageModelOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// The type of words from the custom language model's words resource on which to train the model:
	// * `all` (the default) trains the model on all new words, regardless of whether they were extracted from corpora or
	// grammars or were added or modified by the user.
	// * `user` trains the model only on new words that were added or modified by the user directly. The model is not
	// trained on new words extracted from corpora or grammars.
	WordTypeToAdd *string `json:"word_type_to_add,omitempty"`

	// Specifies a customization weight for the custom language model. The customization weight tells the service how much
	// weight to give to words from the custom language model compared to those from the base model for speech recognition.
	// Specify a value between 0.0 and 1.0; the default is 0.3.
	//
	// The default value yields the best performance in general. Assign a higher value if your audio makes frequent use of
	// OOV words from the custom model. Use caution when setting the weight: a higher value can improve the accuracy of
	// phrases from the custom model's domain, but it can negatively affect performance on non-domain phrases.
	//
	// The value that you assign is used for all recognition requests that use the model. You can override it for any
	// recognition request by specifying a customization weight for that request.
	CustomizationWeight *float64 `json:"customization_weight,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type UnregisterCallbackOptions struct {

	// The callback URL that is to be unregistered.
	CallbackURL *string `json:"callback_url" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type UpgradeAcousticModelOptions struct {

	// The customization ID (GUID) of the custom acoustic model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// If the custom acoustic model was trained with a custom language model, the customization ID (GUID) of that custom
	// language model. The custom language model must be upgraded before the custom acoustic model can be upgraded. The
	// credentials specified with the request must own both custom models.
	CustomLanguageModelID *string `json:"custom_language_model_id,omitempty"`

	// If `true`, forces the upgrade of a custom acoustic model for which no input data has been modified since it was last
	// trained. Use this parameter only to force the upgrade of a custom acoustic model that is trained with a custom
	// language model, and only if you receive a 400 response code and the message `No input data modified since last
	// training`. See [Upgrading a custom acoustic
	// model](https://cloud.ibm.com/docs/services/speech-to-text/custom-upgrade.html#upgradeAcoustic).
	Force *bool `json:"force,omitempty"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type UpgradeLanguageModelOptions struct {

	// The customization ID (GUID) of the custom language model that is to be used for the request. You must make the
	// request with credentials for the instance of the service that owns the custom model.
	CustomizationID *string `json:"customization_id" validate:"required"`

	// Allows users to set headers to be GDPR compliant
	Headers map[string]string
}

type WebsocketRecognitionResults struct {
	// Acknowledges that a start/end message was received, and indicates
	// the start/end of the audio data
	State string `json:"state,omitempty"`

	SpeechRecognitionResults
}

type Word struct {

	// A word from the custom model's words resource. The spelling of the word is used to train the model.
	Word *string `json:"word" validate:"required"`

	// An array of pronunciations for the word. The array can include the sounds-like pronunciation automatically generated
	// by the service if none is provided for the word; the service adds this pronunciation when it finishes processing the
	// word.
	SoundsLike []string `json:"sounds_like" validate:"required"`

	// The spelling of the word that the service uses to display the word in a transcript. The field contains an empty
	// string if no display-as value is provided for the word, in which case the word is displayed as it is spelled.
	DisplayAs *string `json:"display_as" validate:"required"`

	// A sum of the number of times the word is found across all corpora. For example, if the word occurs five times in one
	// corpus and seven times in another, its count is `12`. If you add a custom word to a model before it is added by any
	// corpora, the count begins at `1`; if the word is added from a corpus first and later modified, the count reflects
	// only the number of times it is found in corpora.
	Count *int64 `json:"count" validate:"required"`

	// An array of sources that describes how the word was added to the custom model's words resource. For OOV words added
	// from a corpus, includes the name of the corpus; if the word was added by multiple corpora, the names of all corpora
	// are listed. If the word was modified or added by the user directly, the field includes the string `user`.
	Source []string `json:"source" validate:"required"`

	// If the service discovered one or more problems that you need to correct for the word's definition, an array that
	// describes each of the errors.
	Error []WordError `json:"error,omitempty"`
}

type WordAlternativeResult struct {

	// A confidence score for the word alternative hypothesis in the range of 0.0 to 1.0.
	Confidence *float64 `json:"confidence" validate:"required"`

	// An alternative hypothesis for a word from the input audio.
	Word *string `json:"word" validate:"required"`
}

type WordAlternativeResults struct {

	// The start time in seconds of the word from the input audio that corresponds to the word alternatives.
	StartTime *float64 `json:"start_time" validate:"required"`

	// The end time in seconds of the word from the input audio that corresponds to the word alternatives.
	EndTime *float64 `json:"end_time" validate:"required"`

	// An array of alternative hypotheses for a word from the input audio.
	Alternatives []WordAlternativeResult `json:"alternatives" validate:"required"`
}

type WordError struct {

	// A key-value pair that describes an error associated with the definition of a word in the words resource. Each pair
	// has the format `"element": "message"`, where `element` is the aspect of the definition that caused the problem and
	// `message` describes the problem. The following example describes a problem with one of the word's sounds-like
	// definitions: `"{sounds_like_string}": "Numbers are not allowed in sounds-like. You can try for example
	// '{suggested_string}'."` You must correct the error before you can train the model.
	Element *string `json:"element" validate:"required"`
}

type Words struct {

	// An array of `Word` objects that provides information about each word in the custom model's words resource. The array
	// is empty if the custom model has no words.
	Words []Word `json:"words" validate:"required"`
}