Api-Roll 50: 2017-06-12

generated/googleapis/lib/translate/v2.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.translate.v2;
 
 import 'dart:core' as core;
 import 'dart:collection' as collection;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
 
 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
     ApiRequestError, DetailedApiRequestError;
 
 const core.String USER_AGENT = 'dart-api-client translate/v2';
 
-/** Translates text from one language to another. */
+/**
+ * The Google Cloud Translation API lets websites and programs integrate with
+ *     Google Translate programmatically.
+ */
 class TranslateApi {
+  /** View and manage your data across Google Cloud Platform services */
+  static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
+
+  /** Translate text from one language to another using Google Translate */
+  static const CloudTranslationScope = "https://www.googleapis.com/auth/cloud-translation";
+
 
   final commons.ApiRequester _requester;
 
   DetectionsResourceApi get detections => new DetectionsResourceApi(_requester);
   LanguagesResourceApi get languages => new LanguagesResourceApi(_requester);
   TranslationsResourceApi get translations => new TranslationsResourceApi(_requester);
 
-  TranslateApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "language/translate/"}) :
+  TranslateApi(http.Client client, {core.String rootUrl: "https://translation.googleapis.com/", core.String servicePath: "language/translate/"}) :
       _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
 class DetectionsResourceApi {
   final commons.ApiRequester _requester;
 
   DetectionsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Detect the language of text.
+   * Detects the language of text within a request.
+   *
+   * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * [q] - The text to detect
+   * Completes with a [DetectionsListResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<DetectionsListResponse> detect(DetectLanguageRequest request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v2/detect';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new DetectionsListResponse.fromJson(data));
+  }
+
+  /**
+   * Detects the language of text within a request.
+   *
+   * Request parameters:
+   *
+   * [q] - The input text upon which to perform language detection. Repeat this
+   * parameter to perform language detection on multiple text inputs.
    *
    * Completes with a [DetectionsListResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
   async.Future<DetectionsListResponse> list(core.List<core.String> q) {
@@ skipping 24 matching lines @@
 }
 
 
 class LanguagesResourceApi {
   final commons.ApiRequester _requester;
 
   LanguagesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * List the source/target languages supported by the API
+   * Returns a list of supported languages for translation.
    *
    * Request parameters:
    *
-   * [target] - the language and collation in which the localized results should
-   * be returned
+   * [target] - The language to use to return localized, human readable names of
+   * supported
+   * languages.
+   *
+   * [model] - The model type for which supported languages should be returned.
    *
    * Completes with a [LanguagesListResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<LanguagesListResponse> list({core.String target}) {
+  async.Future<LanguagesListResponse> list({core.String target, core.String model}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (target != null) {
       _queryParams["target"] = [target];
     }
+    if (model != null) {
+      _queryParams["model"] = [model];
+    }
 
     _url = 'v2/languages';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new LanguagesListResponse.fromJson(data));
   }
 
 }
 
 
 class TranslationsResourceApi {
   final commons.ApiRequester _requester;
 
   TranslationsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
-   * Returns text translations from one language to another.
+   * Translates input text, returning translated text.
    *
    * Request parameters:
    *
-   * [q] - The text to translate
+   * [q] - The input text to translate. Repeat this parameter to perform
+   * translation
+   * operations on multiple text inputs.
    *
-   * [target] - The target language into which the text should be translated
+   * [target] - The language to use for translation of the input text, set to
+   * one of the
+   * language codes listed in Language Support.
+   *
+   * [source] - The language of the source text, set to one of the language
+   * codes listed in
+   * Language Support. If the source language is not specified, the API will
+   * attempt to identify the source language automatically and return it within
+   * the response.
    *
    * [cid] - The customization id for translate
    *
-   * [format] - The format of the text
+   * [format] - The format of the source text, in either HTML (default) or
+   * plain-text. A
+   * value of "html" indicates HTML and a value of "text" indicates plain-text.
    * Possible string values are:
    * - "html" : Specifies the input is in HTML
    * - "text" : Specifies the input is in plain textual format
    *
-   * [source] - The source language of the text
+   * [model] - The `model` type requested for this translation. Valid values are
+   * listed in public documentation.
    *
    * Completes with a [TranslationsListResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<TranslationsListResponse> list(core.List<core.String> q, core.String target, {core.List<core.String> cid, core.String format, core.String source}) {
+  async.Future<TranslationsListResponse> list(core.List<core.String> q, core.String target, {core.String source, core.List<core.String> cid, core.String format, core.String model}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (q == null || q.isEmpty) {
       throw new core.ArgumentError("Parameter q is required.");
     }
     _queryParams["q"] = q;
     if (target == null) {
       throw new core.ArgumentError("Parameter target is required.");
     }
     _queryParams["target"] = [target];
+    if (source != null) {
+      _queryParams["source"] = [source];
+    }
     if (cid != null) {
       _queryParams["cid"] = cid;
     }
     if (format != null) {
       _queryParams["format"] = [format];
     }
-    if (source != null) {
-      _queryParams["source"] = [source];
+    if (model != null) {
+      _queryParams["model"] = [model];
     }
 
     _url = 'v2';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TranslationsListResponse.fromJson(data));
   }
 
+  /**
+   * Translates input text, returning translated text.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [TranslationsListResponse].
+   *
+   * Completes with a [commons.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method will complete with the same error.
+   */
+  async.Future<TranslationsListResponse> translate(TranslateTextRequest request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+    _url = 'v2';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new TranslationsListResponse.fromJson(data));
+  }
+
 }
 
 
 
+/** The request message for language detection. */
+class DetectLanguageRequest {
+  /**
+   * The input text upon which to perform language detection. Repeat this
+   * parameter to perform language detection on multiple text inputs.
+   */
+  core.List<core.String> q;
+
+  DetectLanguageRequest();
+
+  DetectLanguageRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("q")) {
+      q = _json["q"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (q != null) {
+      _json["q"] = q;
+    }
+    return _json;
+  }
+}
+
 class DetectionsListResponse {
   /** A detections contains detection results of several text */
   core.List<DetectionsResource> detections;
 
   DetectionsListResponse();
 
   DetectionsListResponse.fromJson(core.Map _json) {
     if (_json.containsKey("detections")) {
       detections = _json["detections"].map((value) => new DetectionsResource.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (detections != null) {
       _json["detections"] = detections.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 class DetectionsResourceElement {
-  /** The confidence of the detection resul of this language. */
+  /** The confidence of the detection result of this language. */
   core.double confidence;
   /** A boolean to indicate is the language detection result reliable. */
   core.bool isReliable;
-  /** The language we detect */
+  /** The language we detected. */
   core.String language;
 
   DetectionsResourceElement();
 
   DetectionsResourceElement.fromJson(core.Map _json) {
     if (_json.containsKey("confidence")) {
       confidence = _json["confidence"];
     }
     if (_json.containsKey("isReliable")) {
       isReliable = _json["isReliable"];
     }
     if (_json.containsKey("language")) {
       language = _json["language"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (confidence != null) {
       _json["confidence"] = confidence;
     }
     if (isReliable != null) {
       _json["isReliable"] = isReliable;
     }
     if (language != null) {
       _json["language"] = language;
     }
     return _json;
   }
 }
 
 /**
  * An array of languages which we detect for the given text The most likely
  * language list first.
  */
 class DetectionsResource
     extends collection.ListBase<DetectionsResourceElement> {
   final core.List<DetectionsResourceElement> _inner;
 
   DetectionsResource() : _inner = [];
 
   DetectionsResource.fromJson(core.List json)
       : _inner = json.map((value) => new DetectionsResourceElement.fromJson(value)).toList();
 
-  core.List toJson() {
+  core.List<core.Map<core.String, core.Object>> toJson() {
     return _inner.map((value) => (value).toJson()).toList();
   }
 
   DetectionsResourceElement operator [](core.int key) => _inner[key];
 
   void operator []=(core.int key, DetectionsResourceElement value) {
     _inner[key] = value;
   }
 
   core.int get length => _inner.length;
 
   void set length(core.int newLength) {
     _inner.length = newLength;
   }
 }
 
+/** The request message for discovering supported languages. */
+class GetSupportedLanguagesRequest {
+  /**
+   * The language to use to return localized, human readable names of supported
+   * languages.
+   */
+  core.String target;
+
+  GetSupportedLanguagesRequest();
+
+  GetSupportedLanguagesRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("target")) {
+      target = _json["target"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (target != null) {
+      _json["target"] = target;
+    }
+    return _json;
+  }
+}
+
 class LanguagesListResponse {
   /**
    * List of source/target languages supported by the translation API. If target
    * parameter is unspecified, the list is sorted by the ASCII code point order
    * of the language code. If target parameter is specified, the list is sorted
    * by the collation order of the language name in the target language.
    */
   core.List<LanguagesResource> languages;
 
   LanguagesListResponse();
 
   LanguagesListResponse.fromJson(core.Map _json) {
     if (_json.containsKey("languages")) {
       languages = _json["languages"].map((value) => new LanguagesResource.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (languages != null) {
       _json["languages"] = languages.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 class LanguagesResource {
-  /** The language code. */
+  /**
+   * Supported language code, generally consisting of its ISO 639-1
+   * identifier. (E.g. 'en', 'ja'). In certain cases, BCP-47 codes including
+   * language + region identifiers are returned (e.g. 'zh-TW' and 'zh-CH')
+   */
   core.String language;
-  /** The localized name of the language if target parameter is given. */
+  /** Human readable name of the language localized to the target language. */
   core.String name;
 
   LanguagesResource();
 
   LanguagesResource.fromJson(core.Map _json) {
     if (_json.containsKey("language")) {
       language = _json["language"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (language != null) {
       _json["language"] = language;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
   }
 }
 
+/** The main translation request message for the Cloud Translation API. */
+class TranslateTextRequest {
+  /**
+   * The format of the source text, in either HTML (default) or plain-text. A
+   * value of "html" indicates HTML and a value of "text" indicates plain-text.
+   */
+  core.String format;
+  /**
+   * The `model` type requested for this translation. Valid values are
+   * listed in public documentation.
+   */
+  core.String model;
+  /**
+   * The input text to translate. Repeat this parameter to perform translation
+   * operations on multiple text inputs.
+   */
+  core.List<core.String> q;
+  /**
+   * The language of the source text, set to one of the language codes listed in
+   * Language Support. If the source language is not specified, the API will
+   * attempt to identify the source language automatically and return it within
+   * the response.
+   */
+  core.String source;
+  /**
+   * The language to use for translation of the input text, set to one of the
+   * language codes listed in Language Support.
+   */
+  core.String target;
+
+  TranslateTextRequest();
+
+  TranslateTextRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("format")) {
+      format = _json["format"];
+    }
+    if (_json.containsKey("model")) {
+      model = _json["model"];
+    }
+    if (_json.containsKey("q")) {
+      q = _json["q"];
+    }
+    if (_json.containsKey("source")) {
+      source = _json["source"];
+    }
+    if (_json.containsKey("target")) {
+      target = _json["target"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (format != null) {
+      _json["format"] = format;
+    }
+    if (model != null) {
+      _json["model"] = model;
+    }
+    if (q != null) {
+      _json["q"] = q;
+    }
+    if (source != null) {
+      _json["source"] = source;
+    }
+    if (target != null) {
+      _json["target"] = target;
+    }
+    return _json;
+  }
+}
+
+/** The main language translation response message. */
 class TranslationsListResponse {
   /** Translations contains list of translation results of given text */
   core.List<TranslationsResource> translations;
 
   TranslationsListResponse();
 
   TranslationsListResponse.fromJson(core.Map _json) {
     if (_json.containsKey("translations")) {
       translations = _json["translations"].map((value) => new TranslationsResource.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (translations != null) {
       _json["translations"] = translations.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 class TranslationsResource {
-  /** Detected source language if source parameter is unspecified. */
+  /**
+   * The source language of the initial request, detected automatically, if
+   * no source language was passed within the initial request. If the
+   * source language was passed, auto-detection of the language will not
+   * occur and this field will be empty.
+   */
   core.String detectedSourceLanguage;
-  /** The translation. */
+  /**
+   * The `model` type used for this translation. Valid values are
+   * listed in public documentation. Can be different from requested `model`.
+   * Present only if specific model type was explicitly requested.
+   */
+  core.String model;
+  /** Text translated into the target language. */
   core.String translatedText;
 
   TranslationsResource();
 
   TranslationsResource.fromJson(core.Map _json) {
     if (_json.containsKey("detectedSourceLanguage")) {
       detectedSourceLanguage = _json["detectedSourceLanguage"];
     }
+    if (_json.containsKey("model")) {
+      model = _json["model"];
+    }
     if (_json.containsKey("translatedText")) {
       translatedText = _json["translatedText"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (detectedSourceLanguage != null) {
       _json["detectedSourceLanguage"] = detectedSourceLanguage;
     }
+    if (model != null) {
+      _json["model"] = model;
+    }
     if (translatedText != null) {
       _json["translatedText"] = translatedText;
     }
     return _json;
   }
 }