Api-roll 45: 2017-02-13

generated/googleapis_beta/lib/speech/v1beta1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.speech.v1beta1;
 
 import 'dart:core' as core;
 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;
@@ skipping 30 matching lines @@
    * makes a best effort to cancel the operation, but success is not
    * guaranteed.  If the server doesn't support this method, it returns
    * `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
    * Operations.GetOperation or
    * other methods to check whether the cancellation succeeded or whether the
    * operation completed despite cancellation. On successful cancellation,
    * the operation is not deleted; instead, it becomes an operation with
    * an Operation.error value with a google.rpc.Status.code of 1,
    * corresponding to `Code.CANCELLED`.
    *
-   * [request] - The metadata request object.
-   *
    * Request parameters:
    *
    * [name] - The name of the operation resource to be cancelled.
    * Value must have pattern "^[^/]+$".
    *
    * Completes with a [Empty].
    *
    * 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<Empty> cancel(CancelOperationRequest request, core.String name) {
+  async.Future<Empty> cancel(core.String name) {
     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());
-    }
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1beta1/operations/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 90 matching lines @@
 
   /**
    * Lists operations that match the specified filter in the request. If the
    * server doesn't support this method, it returns `UNIMPLEMENTED`.
    *
    * NOTE: the `name` binding below allows API services to override the binding
    * to use different resource name schemes, such as `users / * /operations`.
    *
    * Request parameters:
    *
+   * [name] - The name of the operation collection.
+   *
+   * [pageToken] - The standard list page token.
+   *
    * [pageSize] - The standard list page size.
    *
    * [filter] - The standard list filter.
    *
-   * [name] - The name of the operation collection.
-   *
-   * [pageToken] - The standard list page token.
-   *
    * Completes with a [ListOperationsResponse].
    *
    * 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<ListOperationsResponse> list({core.int pageSize, core.String filter, core.String name, core.String pageToken}) {
+  async.Future<ListOperationsResponse> list({core.String name, core.String pageToken, core.int pageSize, core.String filter}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (name != null) {
+      _queryParams["name"] = [name];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
-    if (name != null) {
-      _queryParams["name"] = [name];
-    }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
 
     _url = 'v1beta1/operations';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 91 matching lines @@
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SyncRecognizeResponse.fromJson(data));
   }
 
 }
 
 
 
 /**
- * `AsyncRecognizeRequest` is the top-level message sent by the client for
- * the `AsyncRecognize` method.
+ * The top-level message sent by the client for the `AsyncRecognize` method.
  */
 class AsyncRecognizeRequest {
-  /** [Required] The audio data to be recognized. */
+  /** *Required* The audio data to be recognized. */
   RecognitionAudio audio;
   /**
-   * [Required] The `config` message provides information to the recognizer
-   * that specifies how to process the request.
+   * *Required* Provides information to the recognizer that specifies how to
+   * process the request.
    */
   RecognitionConfig config;
 
   AsyncRecognizeRequest();
 
   AsyncRecognizeRequest.fromJson(core.Map _json) {
     if (_json.containsKey("audio")) {
       audio = new RecognitionAudio.fromJson(_json["audio"]);
     }
     if (_json.containsKey("config")) {
       config = new RecognitionConfig.fromJson(_json["config"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (audio != null) {
       _json["audio"] = (audio).toJson();
     }
     if (config != null) {
       _json["config"] = (config).toJson();
     }
     return _json;
   }
 }
 
-/** The request message for Operations.CancelOperation. */
-class CancelOperationRequest {
-
-  CancelOperationRequest();
-
-  CancelOperationRequest.fromJson(core.Map _json) {
-  }
-
-  core.Map toJson() {
-    var _json = new core.Map();
-    return _json;
-  }
-}
-
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
  * empty messages in your APIs. A typical example is to use it as the request
  * or the response type of an API method. For instance:
  *
  *     service Foo {
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
  * The JSON representation for `Empty` is empty JSON object `{}`.
@@ skipping 173 matching lines @@
       _json["content"] = content;
     }
     if (uri != null) {
       _json["uri"] = uri;
     }
     return _json;
   }
 }
 
 /**
- * The `RecognitionConfig` message provides information to the recognizer
- * that specifies how to process the request.
+ * Provides information to the recognizer that specifies how to process the
+ * request.
  */
 class RecognitionConfig {
   /**
-   * [Required] Encoding of audio data sent in all `RecognitionAudio` messages.
+   * *Required* Encoding of audio data sent in all `RecognitionAudio` messages.
    * Possible string values are:
    * - "ENCODING_UNSPECIFIED" : Not specified. Will return result
    * google.rpc.Code.INVALID_ARGUMENT.
    * - "LINEAR16" : Uncompressed 16-bit signed little-endian samples (Linear
    * PCM).
    * This is the only encoding that may be used by `AsyncRecognize`.
    * - "FLAC" : This is the recommended encoding for `SyncRecognize` and
    * `StreamingRecognize` because it uses lossless compression; therefore
    * recognition accuracy is not compromised by a lossy codec.
    *
    * The stream FLAC (Free Lossless Audio Codec) encoding is specified at:
    * http://flac.sourceforge.net/documentation.html.
    * 16-bit and 24-bit samples are supported.
    * Not all fields in STREAMINFO are supported.
    * - "MULAW" : 8-bit samples that compand 14-bit audio samples using G.711
    * PCMU/mu-law.
    * - "AMR" : Adaptive Multi-Rate Narrowband codec. `sample_rate` must be 8000
    * Hz.
    * - "AMR_WB" : Adaptive Multi-Rate Wideband codec. `sample_rate` must be
    * 16000 Hz.
    */
   core.String encoding;
   /**
-   * [Optional] The language of the supplied audio as a BCP-47 language tag.
+   * *Optional* The language of the supplied audio as a BCP-47 language tag.
    * Example: "en-GB"  https://www.rfc-editor.org/rfc/bcp/bcp47.txt
    * If omitted, defaults to "en-US". See
    * [Language Support](https://cloud.google.com/speech/docs/languages)
    * for a list of the currently supported language codes.
    */
   core.String languageCode;
   /**
-   * [Optional] Maximum number of recognition hypotheses to be returned.
+   * *Optional* Maximum number of recognition hypotheses to be returned.
    * Specifically, the maximum number of `SpeechRecognitionAlternative` messages
    * within each `SpeechRecognitionResult`.
    * The server may return fewer than `max_alternatives`.
    * Valid values are `0`-`30`. A value of `0` or `1` will return a maximum of
-   * `1`. If omitted, defaults to `1`.
+   * one. If omitted, will return a maximum of one.
    */
   core.int maxAlternatives;
   /**
-   * [Optional] If set to `true`, the server will attempt to filter out
+   * *Optional* If set to `true`, the server will attempt to filter out
    * profanities, replacing all but the initial character in each filtered word
    * with asterisks, e.g. "f***". If set to `false` or omitted, profanities
    * won't be filtered out.
    */
   core.bool profanityFilter;
   /**
-   * [Required] Sample rate in Hertz of the audio data sent in all
+   * *Required* Sample rate in Hertz of the audio data sent in all
    * `RecognitionAudio` messages. Valid values are: 8000-48000.
    * 16000 is optimal. For best results, set the sampling rate of the audio
    * source to 16000 Hz. If that's not possible, use the native sample rate of
    * the audio source (instead of re-sampling).
    */
   core.int sampleRate;
   /**
-   * [Optional] A means to provide context to assist the speech recognition.
+   * *Optional* A means to provide context to assist the speech recognition.
    */
   SpeechContext speechContext;
 
   RecognitionConfig();
 
   RecognitionConfig.fromJson(core.Map _json) {
     if (_json.containsKey("encoding")) {
       encoding = _json["encoding"];
     }
     if (_json.containsKey("languageCode")) {
@@ skipping 36 matching lines @@
     return _json;
   }
 }
 
 /**
  * Provides "hints" to the speech recognizer to favor specific words and phrases
  * in the results.
  */
 class SpeechContext {
   /**
-   * [Optional] A list of strings containing words and phrases "hints" so that
+   * *Optional* A list of strings containing words and phrases "hints" so that
    * the speech recognition is more likely to recognize them. This can be used
    * to improve the accuracy for specific words and phrases, for example, if
    * specific commands are typically spoken by the user. This can also be used
    * to add additional words to the vocabulary of the recognizer. See
    * [usage limits](https://cloud.google.com/speech/limits#content).
    */
   core.List<core.String> phrases;
 
   SpeechContext();
 
   SpeechContext.fromJson(core.Map _json) {
     if (_json.containsKey("phrases")) {
       phrases = _json["phrases"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (phrases != null) {
       _json["phrases"] = phrases;
     }
     return _json;
   }
 }
 
 /** Alternative hypotheses (a.k.a. n-best list). */
 class SpeechRecognitionAlternative {
   /**
-   * [Output-only] The confidence estimate between 0.0 and 1.0. A higher number
-   * means the system is more confident that the recognition is correct.
-   * This field is typically provided only for the top hypothesis, and only for
-   * `is_final=true` results.
-   * The default of 0.0 is a sentinel value indicating confidence was not set.
+   * *Output-only* The confidence estimate between 0.0 and 1.0. A higher number
+   * indicates an estimated greater likelihood that the recognized words are
+   * correct. This field is typically provided only for the top hypothesis, and
+   * only for `is_final=true` results. Clients should not rely on the
+   * `confidence` field as it is not guaranteed to be accurate, or even set, in
+   * any of the results.
+   * The default of 0.0 is a sentinel value indicating `confidence` was not set.
    */
   core.double confidence;
   /**
-   * [Output-only] Transcript text representing the words that the user spoke.
+   * *Output-only* Transcript text representing the words that the user spoke.
    */
   core.String transcript;
 
   SpeechRecognitionAlternative();
 
   SpeechRecognitionAlternative.fromJson(core.Map _json) {
     if (_json.containsKey("confidence")) {
       confidence = _json["confidence"];
     }
     if (_json.containsKey("transcript")) {
       transcript = _json["transcript"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (confidence != null) {
       _json["confidence"] = confidence;
     }
     if (transcript != null) {
       _json["transcript"] = transcript;
     }
     return _json;
   }
 }
 
 /** A speech recognition result corresponding to a portion of the audio. */
 class SpeechRecognitionResult {
   /**
-   * [Output-only] May contain one or more recognition hypotheses (up to the
+   * *Output-only* May contain one or more recognition hypotheses (up to the
    * maximum specified in `max_alternatives`).
    */
   core.List<SpeechRecognitionAlternative> alternatives;
 
   SpeechRecognitionResult();
 
   SpeechRecognitionResult.fromJson(core.Map _json) {
     if (_json.containsKey("alternatives")) {
       alternatives = _json["alternatives"].map((value) => new SpeechRecognitionAlternative.fromJson(value)).toList();
     }
@@ skipping 104 matching lines @@
     if (details != null) {
       _json["details"] = details;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }
 
-/**
- * `SyncRecognizeRequest` is the top-level message sent by the client for
- * the `SyncRecognize` method.
- */
+/** The top-level message sent by the client for the `SyncRecognize` method. */
 class SyncRecognizeRequest {
-  /** [Required] The audio data to be recognized. */
+  /** *Required* The audio data to be recognized. */
   RecognitionAudio audio;
   /**
-   * [Required] The `config` message provides information to the recognizer
-   * that specifies how to process the request.
+   * *Required* Provides information to the recognizer that specifies how to
+   * process the request.
    */
   RecognitionConfig config;
 
   SyncRecognizeRequest();
 
   SyncRecognizeRequest.fromJson(core.Map _json) {
     if (_json.containsKey("audio")) {
       audio = new RecognitionAudio.fromJson(_json["audio"]);
     }
     if (_json.containsKey("config")) {
       config = new RecognitionConfig.fromJson(_json["config"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (audio != null) {
       _json["audio"] = (audio).toJson();
     }
     if (config != null) {
       _json["config"] = (config).toJson();
     }
     return _json;
   }
 }
 
 /**
- * `SyncRecognizeResponse` is the only message returned to the client by
- * `SyncRecognize`. It contains the result as zero or more sequential
- * `SpeechRecognitionResult` messages.
+ * The only message returned to the client by `SyncRecognize`. method. It
+ * contains the result as zero or more sequential `SpeechRecognitionResult`
+ * messages.
  */
 class SyncRecognizeResponse {
   /**
-   * [Output-only] Sequential list of transcription results corresponding to
+   * *Output-only* Sequential list of transcription results corresponding to
    * sequential portions of audio.
    */
   core.List<SpeechRecognitionResult> results;
 
   SyncRecognizeResponse();
 
   SyncRecognizeResponse.fromJson(core.Map _json) {
     if (_json.containsKey("results")) {
       results = _json["results"].map((value) => new SpeechRecognitionResult.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (results != null) {
       _json["results"] = results.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }