ibm-watson
Version:
Client library to use the IBM Watson Services
909 lines • 101 kB
JavaScript
"use strict";
/**
* (C) Copyright IBM Corp. 2024.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
/**
* IBM OpenAPI SDK Code Generator Version: 3.96.1-5136e54a-20241108-203028
*/
var extend = require("extend");
var ibm_cloud_sdk_core_1 = require("ibm-cloud-sdk-core");
var common_1 = require("../lib/common");
/**
* The IBM Watson™ Text to Speech service provides APIs that use IBM's speech-synthesis capabilities to synthesize
* text into natural-sounding speech in a variety of languages, dialects, and voices. The service supports at least one
* male or female voice, sometimes both, for each language. The audio is streamed back to the client with minimal delay.
*
*
* For speech synthesis, the service supports a synchronous HTTP Representational State Transfer (REST) interface and a
* WebSocket interface. Both interfaces support plain text and SSML input. SSML is an XML-based markup language that
* provides text annotation for speech-synthesis applications. The WebSocket interface also supports the SSML
* <code><mark></code> element and word timings.
*
* The service offers a customization interface that you can use to define sounds-like or phonetic translations for
* words. A sounds-like translation consists of one or more words that, when combined, sound like the word. A phonetic
* translation is based on the SSML phoneme format for representing a word. You can specify a phonetic translation in
* standard International Phonetic Alphabet (IPA) representation or in the proprietary IBM Symbolic Phonetic
* Representation (SPR).
*
* The service also offers a Tune by Example feature that lets you define custom prompts. You can also define speaker
* models to improve the quality of your custom prompts. The service supports custom prompts only for US English custom
* models and voices.
*
* API Version: 1.0.0
* See: https://cloud.ibm.com/docs/text-to-speech
*/
var TextToSpeechV1 = /** @class */ (function (_super) {
__extends(TextToSpeechV1, _super);
/**
* Construct a TextToSpeechV1 object.
*
* @param {Object} options - Options for the service.
* @param {string} [options.serviceUrl] - The base URL for the service
* @param {OutgoingHttpHeaders} [options.headers] - Default headers that shall be included with every request to the service.
* @param {string} [options.serviceName] - The name of the service to configure
* @param {Authenticator} [options.authenticator] - The Authenticator object used to authenticate requests to the service. Defaults to environment if not set
* @constructor
* @returns {TextToSpeechV1}
*/
function TextToSpeechV1(options) {
var _this = this;
options = options || {};
if (!options.serviceName) {
options.serviceName = TextToSpeechV1.DEFAULT_SERVICE_NAME;
}
// If the caller didn't supply an authenticator, construct one from external configuration.
if (!options.authenticator) {
options.authenticator = (0, ibm_cloud_sdk_core_1.getAuthenticatorFromEnvironment)(options.serviceName);
}
_this = _super.call(this, options) || this;
_this.configureService(options.serviceName);
if (options.serviceUrl) {
_this.setServiceUrl(options.serviceUrl);
}
return _this;
}
/*************************
* voices
************************/
/**
* List voices.
*
* Lists all voices available for use with the service. The information includes the name, language, gender, and other
* details about the voice. The ordering of the list of voices can change from call to call; do not rely on an
* alphabetized or static list of voices. To see information about a specific voice, use the [Get a voice](#getvoice).
*
*
* **See also:** [Listing all
* voices](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices-list#list-all-voices).
*
* @param {Object} [params] - The parameters to send to the service.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.Voices>>}
*/
TextToSpeechV1.prototype.listVoices = function (params) {
var _params = __assign({}, params);
var _requiredParams = [];
var _validParams = ['headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'listVoices');
var parameters = {
options: {
url: '/v1/voices',
method: 'GET',
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Get a voice.
*
* Gets information about the specified voice. The information includes the name, language, gender, and other details
* about the voice. Specify a customization ID to obtain information for a custom model that is defined for the
* language of the specified voice. To list information about all available voices, use the [List voices](#listvoices)
* method.
*
* **See also:** [Listing a specific
* voice](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices-list#list-specific-voice).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.voice - The voice for which information is to be returned.
* @param {string} [params.customizationId] - The customization ID (GUID) of a custom model for which information is
* to be returned. You must make the request with credentials for the instance of the service that owns the custom
* model. Omit the parameter to see information about the specified voice with no customization.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.Voice>>}
*/
TextToSpeechV1.prototype.getVoice = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['voice'];
var _validParams = ['voice', 'customizationId', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var query = {
'customization_id': _params.customizationId,
};
var path = {
'voice': _params.voice,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'getVoice');
var parameters = {
options: {
url: '/v1/voices/{voice}',
method: 'GET',
qs: query,
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/*************************
* synthesis
************************/
/**
* Synthesize audio.
*
* Synthesizes text to audio that is spoken in the specified voice. The service bases its understanding of the
* language for the input text on the specified voice. Use a voice that matches the language of the input text.
*
* The method accepts a maximum of 5 KB of input text in the body of the request, and 8 KB for the URL and headers.
* The 5 KB limit includes any SSML tags that you specify. The service returns the synthesized audio stream as an
* array of bytes.
*
* **See also:** [The HTTP
* interface](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-usingHTTP#usingHTTP).
*
* ### Audio formats (accept types)
*
* The service can return audio in the following formats (MIME types).
* * Where indicated, you can optionally specify the sampling rate (`rate`) of the audio. You must specify a sampling
* rate for the `audio/alaw`, `audio/l16`, and `audio/mulaw` formats. A specified sampling rate must lie in the range
* of 8 kHz to 192 kHz. Some formats restrict the sampling rate to certain values, as noted.
* * For the `audio/l16` format, you can optionally specify the endianness (`endianness`) of the audio:
* `endianness=big-endian` or `endianness=little-endian`.
*
* Use the `Accept` header or the `accept` parameter to specify the requested format of the response audio. If you
* omit an audio format altogether, the service returns the audio in Ogg format with the Opus codec
* (`audio/ogg;codecs=opus`). The service always returns single-channel audio.
* * `audio/alaw` - You must specify the `rate` of the audio.
* * `audio/basic` - The service returns audio with a sampling rate of 8000 Hz.
* * `audio/flac` - You can optionally specify the `rate` of the audio. The default sampling rate is 22,050 Hz.
* * `audio/l16` - You must specify the `rate` of the audio. You can optionally specify the `endianness` of the audio.
* The default endianness is `little-endian`.
* * `audio/mp3` - You can optionally specify the `rate` of the audio. The default sampling rate is 22,050 Hz.
* * `audio/mpeg` - You can optionally specify the `rate` of the audio. The default sampling rate is 22,050 Hz.
* * `audio/mulaw` - You must specify the `rate` of the audio.
* * `audio/ogg` - The service returns the audio in the `vorbis` codec. You can optionally specify the `rate` of the
* audio. The default sampling rate is 22,050 Hz.
* * `audio/ogg;codecs=opus` - You can optionally specify the `rate` of the audio. Only the following values are valid
* sampling rates: `48000`, `24000`, `16000`, `12000`, or `8000`. If you specify a value other than one of these, the
* service returns an error. The default sampling rate is 48,000 Hz.
* * `audio/ogg;codecs=vorbis` - You can optionally specify the `rate` of the audio. The default sampling rate is
* 22,050 Hz.
* * `audio/wav` - You can optionally specify the `rate` of the audio. The default sampling rate is 22,050 Hz.
* * `audio/webm` - The service returns the audio in the `opus` codec. The service returns audio with a sampling rate
* of 48,000 Hz.
* * `audio/webm;codecs=opus` - The service returns audio with a sampling rate of 48,000 Hz.
* * `audio/webm;codecs=vorbis` - You can optionally specify the `rate` of the audio. The default sampling rate is
* 22,050 Hz.
*
* For more information about specifying an audio format, including additional details about some of the formats, see
* [Using audio formats](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-audio-formats).
*
* **Note:** By default, the service returns audio in the Ogg audio format with the Opus codec
* (`audio/ogg;codecs=opus`). However, the Ogg audio format is not supported with the Safari browser. If you are using
* the service with the Safari browser, you must use the `Accept` request header or the `accept` query parameter
* specify a different format in which you want the service to return the audio.
*
* ### Warning messages
*
* If a request includes invalid query parameters, the service returns a `Warnings` response header that provides
* messages about the invalid parameters. The warning includes a descriptive message and a list of invalid argument
* strings. For example, a message such as `"Unknown arguments:"` or `"Unknown url query arguments:"` followed by a
* list of the form `"{invalid_arg_1}, {invalid_arg_2}."` The request succeeds despite the warnings.
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.text - The text to synthesize.
* @param {string} [params.accept] - The requested format (MIME type) of the audio. You can use the `Accept` header or
* the `accept` parameter to specify the audio format. For more information about specifying an audio format, see
* **Audio formats (accept types)** in the method description.
* @param {string} [params.voice] - The voice to use for speech synthesis. If you omit the `voice` parameter, the
* service uses the US English `en-US_MichaelV3Voice` by default.
*
* _For IBM Cloud Pak for Data,_ if you do not install the `en-US_MichaelV3Voice`, you must either specify a voice
* with the request or specify a new default voice for your installation of the service.
*
* **See also:**
* * [Languages and voices](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices)
* * [Using the default
* voice](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices-use#specify-voice-default).
* @param {string} [params.customizationId] - The customization ID (GUID) of a custom model to use for the synthesis.
* If a custom model is specified, it works only if it matches the language of the indicated voice. You must make the
* request with credentials for the instance of the service that owns the custom model. Omit the parameter to use the
* specified voice with no customization.
* @param {string} [params.spellOutMode] - *For German voices,* indicates how the service is to spell out strings of
* individual letters. To indicate the pace of the spelling, specify one of the following values:
* * `default` - The service reads the characters at the rate at which it synthesizes speech for the request. You can
* also omit the parameter entirely to achieve the default behavior.
* * `singles` - The service reads the characters one at a time, with a brief pause between each character.
* * `pairs` - The service reads the characters two at a time, with a brief pause between each pair.
* * `triples` - The service reads the characters three at a time, with a brief pause between each triplet.
*
* For more information, see [Specifying how strings are spelled
* out](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-synthesis-params#params-spell-out-mode).
* @param {number} [params.ratePercentage] - The percentage change from the default speaking rate of the voice that is
* used for speech synthesis. Each voice has a default speaking rate that is optimized to represent a normal rate of
* speech. The parameter accepts an integer that represents the percentage change from the voice's default rate:
* * Specify a signed negative integer to reduce the speaking rate by that percentage. For example, -10 reduces the
* rate by ten percent.
* * Specify an unsigned or signed positive integer to increase the speaking rate by that percentage. For example, 10
* and +10 increase the rate by ten percent.
* * Specify 0 or omit the parameter to get the default speaking rate for the voice.
*
* The parameter affects the rate for an entire request.
*
* For more information, see [Modifying the speaking
* rate](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-synthesis-params#params-rate-percentage).
* @param {number} [params.pitchPercentage] - The percentage change from the default speaking pitch of the voice that
* is used for speech synthesis. Each voice has a default speaking pitch that is optimized to represent a normal tone
* of voice. The parameter accepts an integer that represents the percentage change from the voice's default tone:
* * Specify a signed negative integer to lower the voice's pitch by that percentage. For example, -5 reduces the tone
* by five percent.
* * Specify an unsigned or signed positive integer to increase the voice's pitch by that percentage. For example, 5
* and +5 increase the tone by five percent.
* * Specify 0 or omit the parameter to get the default speaking pitch for the voice.
*
* The parameter affects the pitch for an entire request.
*
* For more information, see [Modifying the speaking
* pitch](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-synthesis-params#params-pitch-percentage).
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<NodeJS.ReadableStream>>}
*/
TextToSpeechV1.prototype.synthesize = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['text'];
var _validParams = ['text', 'accept', 'voice', 'customizationId', 'spellOutMode', 'ratePercentage', 'pitchPercentage', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var body = {
'text': _params.text,
};
var query = {
'voice': _params.voice,
'customization_id': _params.customizationId,
'spell_out_mode': _params.spellOutMode,
'rate_percentage': _params.ratePercentage,
'pitch_percentage': _params.pitchPercentage,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'synthesize');
var parameters = {
options: {
url: '/v1/synthesize',
method: 'POST',
body: body,
qs: query,
responseType: 'stream',
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Content-Type': 'application/json',
'Accept': _params.accept,
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/*************************
* pronunciation
************************/
/**
* Get pronunciation.
*
* Gets the phonetic pronunciation for the specified word. You can request the pronunciation for a specific format.
* You can also request the pronunciation for a specific voice to see the default translation for the language of that
* voice or for a specific custom model to see the translation for that model.
*
* **See also:** [Querying a word from a
* language](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordsQueryLanguage).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.text - The word for which the pronunciation is requested.
* @param {string} [params.voice] - A voice that specifies the language in which the pronunciation is to be returned.
* If you omit the `voice` parameter, the service uses the US English `en-US_MichaelV3Voice` by default. All voices
* for the same language (for example, `en-US`) return the same translation.
*
* _For IBM Cloud Pak for Data,_ if you do not install the `en-US_MichaelV3Voice`, you must either specify a voice
* with the request or specify a new default voice for your installation of the service.
*
* **See also:** [Using the default
* voice](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices-use#specify-voice-default).
* @param {string} [params.format] - The phoneme format in which to return the pronunciation. Omit the parameter to
* obtain the pronunciation in the default format.
* @param {string} [params.customizationId] - The customization ID (GUID) of a custom model for which the
* pronunciation is to be returned. The language of a specified custom model must match the language of the specified
* voice. If the word is not defined in the specified custom model, the service returns the default translation for
* the custom model's language. You must make the request with credentials for the instance of the service that owns
* the custom model. Omit the parameter to see the translation for the specified voice with no customization.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.Pronunciation>>}
*/
TextToSpeechV1.prototype.getPronunciation = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['text'];
var _validParams = ['text', 'voice', 'format', 'customizationId', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var query = {
'text': _params.text,
'voice': _params.voice,
'format': _params.format,
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'getPronunciation');
var parameters = {
options: {
url: '/v1/pronunciation',
method: 'GET',
qs: query,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/*************************
* customModels
************************/
/**
* Create a custom model.
*
* Creates a new empty custom model. You must specify a name for the new custom model. You can optionally specify the
* language and a description for the new model. The model is owned by the instance of the service whose credentials
* are used to create it.
*
* **See also:** [Creating a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customModels#cuModelsCreate).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.name - The name of the new custom model. Use a localized name that matches the language of
* the custom model. Use a name that describes the purpose of the custom model, such as `Medical custom model` or
* `Legal custom model`. Use a name that is unique among all custom models that you own.
*
* Include a maximum of 256 characters in the name. Do not use backslashes, slashes, colons, equal signs, ampersands,
* or question marks in the name.
* @param {string} [params.language] - The language of the new custom model. You create a custom model for a specific
* language, not for a specific voice. A custom model can be used with any voice for its specified language. Omit the
* parameter to use the the default language, `en-US`.
* @param {string} [params.description] - A recommended description of the new custom model. Use a localized
* description that matches the language of the custom model. Include a maximum of 128 characters in the description.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.CustomModel>>}
*/
TextToSpeechV1.prototype.createCustomModel = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['name'];
var _validParams = ['name', 'language', 'description', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var body = {
'name': _params.name,
'language': _params.language,
'description': _params.description,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'createCustomModel');
var parameters = {
options: {
url: '/v1/customizations',
method: 'POST',
body: body,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
'Content-Type': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* List custom models.
*
* Lists metadata such as the name and description for all custom models that are owned by an instance of the service.
* Specify a language to list the custom models for that language only. To see the words and prompts in addition to
* the metadata for a specific custom model, use the [Get a custom model](#getcustommodel) method. You must use
* credentials for the instance of the service that owns a model to list information about it.
*
* **See also:** [Querying all custom
* models](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customModels#cuModelsQueryAll).
*
* @param {Object} [params] - The parameters to send to the service.
* @param {string} [params.language] - The language for which custom models that are owned by the requesting
* credentials are to be returned. Omit the parameter to see all custom models that are owned by the requester.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.CustomModels>>}
*/
TextToSpeechV1.prototype.listCustomModels = function (params) {
var _params = __assign({}, params);
var _requiredParams = [];
var _validParams = ['language', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var query = {
'language': _params.language,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'listCustomModels');
var parameters = {
options: {
url: '/v1/customizations',
method: 'GET',
qs: query,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Update a custom model.
*
* Updates information for the specified custom model. You can update metadata such as the name and description of the
* model. You can also update the words in the model and their translations. Adding a new translation for a word that
* already exists in a custom model overwrites the word's existing translation. A custom model can contain no more
* than 20,000 entries. You must use credentials for the instance of the service that owns a model to update it.
*
* You can define sounds-like or phonetic translations for words. A sounds-like translation consists of one or more
* words that, when combined, sound like the word. Phonetic translations are based on the SSML phoneme format for
* representing a word. You can specify them in standard International Phonetic Alphabet (IPA) representation
*
* <code><phoneme alphabet="ipa" ph="təmˈɑto"></phoneme></code>
*
* or in the proprietary IBM Symbolic Phonetic Representation (SPR)
*
* <code><phoneme alphabet="ibm" ph="1gAstroEntxrYFXs"></phoneme></code>
*
* **See also:**
* * [Updating a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customModels#cuModelsUpdate)
* * [Adding words to a Japanese custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuJapaneseAdd)
* * [Understanding
* customization](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customIntro#customIntro).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {string} [params.name] - A new name for the custom model.
* @param {string} [params.description] - A new description for the custom model.
* @param {Word[]} [params.words] - An array of `Word` objects that provides the words and their translations that are
* to be added or updated for the custom model. Pass an empty array to make no additions or updates.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.EmptyObject>>}
*/
TextToSpeechV1.prototype.updateCustomModel = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId'];
var _validParams = ['customizationId', 'name', 'description', 'words', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var body = {
'name': _params.name,
'description': _params.description,
'words': _params.words,
};
var path = {
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'updateCustomModel');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}',
method: 'POST',
body: body,
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
'Content-Type': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Get a custom model.
*
* Gets all information about a specified custom model. In addition to metadata such as the name and description of
* the custom model, the output includes the words and their translations that are defined for the model, as well as
* any prompts that are defined for the model. To see just the metadata for a model, use the [List custom
* models](#listcustommodels) method.
*
* **See also:** [Querying a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customModels#cuModelsQuery).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.CustomModel>>}
*/
TextToSpeechV1.prototype.getCustomModel = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId'];
var _validParams = ['customizationId', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var path = {
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'getCustomModel');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}',
method: 'GET',
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Delete a custom model.
*
* Deletes the specified custom model. You must use credentials for the instance of the service that owns a model to
* delete it.
*
* **See also:** [Deleting a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customModels#cuModelsDelete).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.EmptyObject>>}
*/
TextToSpeechV1.prototype.deleteCustomModel = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId'];
var _validParams = ['customizationId', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var path = {
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'deleteCustomModel');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}',
method: 'DELETE',
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/*************************
* customWords
************************/
/**
* Add custom words.
*
* Adds one or more words and their translations to the specified custom model. Adding a new translation for a word
* that already exists in a custom model overwrites the word's existing translation. A custom model can contain no
* more than 20,000 entries. You must use credentials for the instance of the service that owns a model to add words
* to it.
*
* You can define sounds-like or phonetic translations for words. A sounds-like translation consists of one or more
* words that, when combined, sound like the word. Phonetic translations are based on the SSML phoneme format for
* representing a word. You can specify them in standard International Phonetic Alphabet (IPA) representation
*
* <code><phoneme alphabet="ipa" ph="təmˈɑto"></phoneme></code>
*
* or in the proprietary IBM Symbolic Phonetic Representation (SPR)
*
* <code><phoneme alphabet="ibm" ph="1gAstroEntxrYFXs"></phoneme></code>
*
* **See also:**
* * [Adding multiple words to a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordsAdd)
* * [Adding words to a Japanese custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuJapaneseAdd)
* * [Understanding
* customization](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customIntro#customIntro).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {Word[]} params.words - The [Add custom words](#addwords) method accepts an array of `Word` objects. Each
* object provides a word that is to be added or updated for the custom model and the word's translation.
*
* The [List custom words](#listwords) method returns an array of `Word` objects. Each object shows a word and its
* translation from the custom model. The words are listed in alphabetical order, with uppercase letters listed before
* lowercase letters. The array is empty if the custom model contains no words.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.EmptyObject>>}
*/
TextToSpeechV1.prototype.addWords = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId', 'words'];
var _validParams = ['customizationId', 'words', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var body = {
'words': _params.words,
};
var path = {
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'addWords');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}/words',
method: 'POST',
body: body,
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
'Content-Type': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* List custom words.
*
* Lists all of the words and their translations for the specified custom model. The output shows the translations as
* they are defined in the model. You must use credentials for the instance of the service that owns a model to list
* its words.
*
* **See also:** [Querying all words from a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordsQueryModel).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.Words>>}
*/
TextToSpeechV1.prototype.listWords = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId'];
var _validParams = ['customizationId', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var path = {
'customization_id': _params.customizationId,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'listWords');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}/words',
method: 'GET',
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Add a custom word.
*
* Adds a single word and its translation to the specified custom model. Adding a new translation for a word that
* already exists in a custom model overwrites the word's existing translation. A custom model can contain no more
* than 20,000 entries. You must use credentials for the instance of the service that owns a model to add a word to
* it.
*
* You can define sounds-like or phonetic translations for words. A sounds-like translation consists of one or more
* words that, when combined, sound like the word. Phonetic translations are based on the SSML phoneme format for
* representing a word. You can specify them in standard International Phonetic Alphabet (IPA) representation
*
* <code><phoneme alphabet="ipa" ph="təmˈɑto"></phoneme></code>
*
* or in the proprietary IBM Symbolic Phonetic Representation (SPR)
*
* <code><phoneme alphabet="ibm" ph="1gAstroEntxrYFXs"></phoneme></code>
*
* **See also:**
* * [Adding a single word to a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordAdd)
* * [Adding words to a Japanese custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuJapaneseAdd)
* * [Understanding
* customization](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customIntro#customIntro).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {string} params.word - The word that is to be added or updated for the custom model.
* @param {string} params.translation - The phonetic or sounds-like translation for the word. A phonetic translation
* is based on the SSML format for representing the phonetic string of a word either as an IPA translation or as an
* IBM SPR translation. A sounds-like is one or more words that, when combined, sound like the word.
* @param {string} [params.partOfSpeech] - **Japanese only.** The part of speech for the word. The service uses the
* value to produce the correct intonation for the word. You can create only a single entry, with or without a single
* part of speech, for any word; you cannot create multiple entries with different parts of speech for the same word.
* For more information, see [Working with Japanese
* entries](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-rules#jaNotes).
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.EmptyObject>>}
*/
TextToSpeechV1.prototype.addWord = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId', 'word', 'translation'];
var _validParams = ['customizationId', 'word', 'translation', 'partOfSpeech', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var body = {
'translation': _params.translation,
'part_of_speech': _params.partOfSpeech,
};
var path = {
'customization_id': _params.customizationId,
'word': _params.word,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'addWord');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}/words/{word}',
method: 'PUT',
body: body,
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Content-Type': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Get a custom word.
*
* Gets the translation for a single word from the specified custom model. The output shows the translation as it is
* defined in the model. You must use credentials for the instance of the service that owns a model to list its words.
*
*
* **See also:** [Querying a single word from a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordQueryModel).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {string} params.word - The word that is to be queried from the custom model.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
* @returns {Promise<TextToSpeechV1.Response<TextToSpeechV1.Translation>>}
*/
TextToSpeechV1.prototype.getWord = function (params) {
var _params = __assign({}, params);
var _requiredParams = ['customizationId', 'word'];
var _validParams = ['customizationId', 'word', 'headers'];
var _validationErrors = (0, ibm_cloud_sdk_core_1.validateParams)(_params, _requiredParams, _validParams);
if (_validationErrors) {
return Promise.reject(_validationErrors);
}
var path = {
'customization_id': _params.customizationId,
'word': _params.word,
};
var sdkHeaders = (0, common_1.getSdkHeaders)(TextToSpeechV1.DEFAULT_SERVICE_NAME, 'v1', 'getWord');
var parameters = {
options: {
url: '/v1/customizations/{customization_id}/words/{word}',
method: 'GET',
path: path,
},
defaultOptions: extend(true, {}, this.baseOptions, {
headers: extend(true, sdkHeaders, {
'Accept': 'application/json',
}, _params.headers),
}),
};
return this.createRequest(parameters);
};
/**
* Delete a custom word.
*
* Deletes a single word from the specified custom model. You must use credentials for the instance of the service
* that owns a model to delete its words.
*
* **See also:** [Deleting a word from a custom
* model](https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-customWords#cuWordDelete).
*
* @param {Object} params - The parameters to send to the service.
* @param {string} params.customizationId - The customization ID (GUID) of the custom model. You must make the request
* with credentials for the instance of the service that owns the custom model.
* @param {string} params.word - The word that is to be deleted from the custom model.
* @param {OutgoingHttpHeaders} [params.headers] - Custom request header