ibm_watson 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7836c1857159d3d0a056c2a9afd46009534c5a8e84b6b716fbfef53c139bffb
+  data.tar.gz: 83142f7639dafcf4450cba44766cae7a635e7c341bf31b222fb4698ffea46815
+SHA512:
+  metadata.gz: f396810bad65041babcf1e5e2aee11b250973649b5412ecbffdd2c4386ddc94182c5d1d45dc9d8b99e1c44b9c5955777802bb17bb2dbf2a7ba428eeef5d3bde3
+  data.tar.gz: 791fa8d8c263c62c60e95fc3cf589d02a4093e12ee42da841061dffdc25b3212dcb9fec8cddc0bc4afe717fc0b2fdeeb3d25f2439f4a0699868604f2d0731d79

data/README.md

@@ -0,0 +1,258 @@
+# IBM Watson Ruby SDK
+
+[![Build Status](https://travis-ci.org/watson-developer-cloud/ruby-sdk.svg?branch=master)](https://travis-ci.org/watson-developer-cloud/ruby-sdk)
+[![Slack](https://wdc-slack-inviter.mybluemix.net/badge.svg)](https://wdc-slack-inviter.mybluemix.net)
+[![codecov.io](https://codecov.io/github/watson-developer-cloud/ruby-sdk/coverage.svg?branch=master)](https://codecov.io/github/watson-developer-cloud/ruby-sdk?branch=master)
+[![Gem Version](https://badge.fury.io/rb/ibm_watson.svg)](https://badge.fury.io/rb/ibm_watson)
+
+Ruby gem to quickly get started with the various [IBM Watson][wdc] services.
+
+<details>
+  <summary>Table of Contents</summary>
+
+  * [Before you begin](#before-you-begin)
+  * [Installation](#installation)
+  * [Examples](#examples)
+  * [Running in IBM Cloud](#running-in-ibm-cloud)
+  * [Authentication](#authentication)
+    * [Getting credentials](#getting-credentials)
+    * [IAM](#iam)
+    * [Username and password](#username-and-password)
+  * [Sending requests asynchronously](#sending-requests-asynchronously)
+  * [Sending request headers](#sending-request-headers)
+  * [Parsing HTTP response info](#parsing-http-response-info)
+  * [Using Websockets](#using-websockets)
+  * [Ruby version](#ruby-version)
+  * [Contributing](#contributing)
+  * [License](#license)
+
+</details>
+
+## Before you begin
+* You need an [IBM Cloud][ibm-cloud-onboarding] account.
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install ibm_watson
+```
+
+Install with development dependencies:
+
+```bash
+gem install --dev ibm_watson
+```
+
+Inside of your Ruby program do:
+
+```ruby
+require "ibm_watson"
+```
+
+## Examples
+
+The [examples][examples] folder has basic and advanced examples. The examples within each service assume that you already have [service credentials](#getting-credentials).
+
+## Running in IBM Cloud
+
+If you run your app in IBM Cloud, the SDK gets credentials from the [`VCAP_SERVICES`][vcap_services] environment variable. 
+
+## Authentication
+
+Watson services are migrating to token-based Identity and Access Management (IAM) authentication.
+
+- With some service instances, you authenticate to the API by using **[IAM](#iam)**.
+- In other instances, you authenticate by providing the **[username and password](#username-and-password)** for the service instance.
+
+### Getting credentials
+To find out which authentication to use, view the service credentials. You find the service credentials for authentication the same way for all Watson services:
+
+1.  Go to the IBM Cloud **[Dashboard][watson-dashboard]** page.
+1.  Either click an existing Watson service instance or click **Create**.
+1.  Click **Show** to view your service credentials.
+1.  Copy the `url` and either `apikey` or `username` and `password`.
+
+### IAM
+
+IBM Cloud is migrating to token-based Identity and Access Management (IAM) authentication. IAM authentication uses a service API key to get an access token that is passed with the call. Access tokens are valid for approximately one hour and must be regenerated.
+
+You supply either an IAM service **API key** or an **access token**:
+
+- Use the API key to have the SDK manage the lifecycle of the access token. The SDK requests an access token, ensures that the access token is valid, and refreshes it if necessary.
+- Use the access token if you want to manage the lifecycle yourself. For details, see [Authenticating with IAM tokens](https://console.bluemix.net/docs/services/watson/getting-started-iam.html).
+
+#### Supplying the IAM API key
+
+```ruby
+# In the constructor, letting the SDK manage the IAM token
+discovery = IBMWatson::DiscoveryV1.new(
+  version: "2017-10-16",
+  iam_api_key: "<iam_api_key>",
+  iam_url: "<iam_url>" # optional - the default value is https://iam.ng.bluemix.net/identity/token
+)
+```
+
+```ruby
+# after instantiation, letting the SDK manage the IAM token
+discovery = IBMWatson::DiscoveryV1.new(version: "2017-10-16")
+discovery._iam_api_key(iam_api_key: "<iam_api_key>")
+```
+
+#### Supplying the access token
+```ruby
+# in the constructor, assuming control of managing IAM token
+discovery = IBMWatson::DiscoveryV1.new(
+  version: "2017-10-16",
+  iam_access_token: "<iam_access_token>"
+)
+```
+
+```ruby
+# after instantiation, assuming control of managing IAM token
+discovery = IBMWatson::DiscoveryV1.new(version: "2017-10-16")
+discovery._iam_access_token(iam_access_token: "<access_token>")
+```
+
+### Username and password
+```ruby
+require "ibm_watson"
+include IBMWatson
+# In the constructor
+discovery = DiscoveryV1.new(version: "2017-10-16", username: "<username>", password: "<password>")
+```
+
+```ruby
+# After instantiation
+discovery = DiscoveryV1.new(version: "2017-10-16")
+discovery.username = "<username>"
+discovery.password = "<password>"
+```
+
+## Sending requests asynchronously
+Requests can be sent asynchronously. There are two asynchronous methods available for the user, `async` & `await`. When used, these methods return an [Ivar][ivar] object.
+* To call a method asynchronously, simply insert `.await` or `.async` into the call: `service.translate` would be `service.async.translate`
+* To access the response from an [Ivar][ivar] object called `future`, simply call `future.value`
+
+When `await` is used, the request is made synchronously.
+```ruby
+speech_to_text = IBMWatson::SpeechToTextV1.new(
+  username: "username",
+  password: "password"
+)
+audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+future = speech_to_text.await.recognize(
+  audio: audio_file
+)
+p future.complete? # If the request is successful, then this will be true
+output = future.value # The response is accessible at future.value
+```
+
+When `async` is used, the request is made asynchronously
+```ruby
+speech_to_text = IBMWatson::SpeechToTextV1.new(
+  username: "username",
+  password: "password"
+)
+audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+future = speech_to_text.async.recognize(
+  audio: audio_file
+)
+p future.complete? # Can be false if the request is still running
+future.wait # Wait for the asynchronous call to finish
+p future.complete? # If the request is successful, then this will now be true
+output = future.value
+```
+
+## Sending request headers
+Custom headers can be passed in any request in the form of a `Hash` as a parameter to the `headers` chainable method. For example, to send a header called `Custom-Header` to a call in Watson Assistant, pass the headers as a parameter to the `headers` chainable method:
+```ruby
+require "ibm_watson"
+include IBMWatson
+
+assistant = AssistantV1.new(
+  username: "xxx",
+  password: "yyy",
+  version: "2017-04-21"
+)
+
+response = assistant.headers(
+  "Custom-Header" => "custom_value"
+  ).list_workspaces
+```
+
+## Parsing HTTP response info
+HTTP requests all return `DetailedResponse` objects that have a `result`, `status`, and `headers`
+```ruby
+require "ibm_watson"
+include IBMWatson
+
+assistant = AssistantV1.new(
+  username: "xxx",
+  password: "yyy",
+  version: "2017-04-21"
+)
+
+response = assistant.headers(
+  "Custom-Header" => "custom_value"
+  ).list_workspaces
+
+p "Status: #{response.status}"
+p "Headers: #{response.headers}"
+p "Result: #{response.result}"
+```
+
+This would give an output of `DetailedResponse` having the structure:
+```ruby
+Status: 200
+Headers: <http response headers>
+Result: <response returned by service>
+```
+
+## Using Websockets
+
+The Speech-to-Text service supports websockets with the `recognize-with-websockets` method. The method accepts a custom callback class. The `eventmachine` loop that the websocket uses blocks the main thread by default. Here is an example of using the websockets method:
+
+```ruby
+require "ibm_watson"
+
+callback = IBMWatson::RecognizeCallback.new
+audio_file = "<Audio File for Analysis>"
+speech_to_text = IBMWatson::SpeechToTextV1.new(
+  username: "<username>",
+  password: "<password>"
+)
+websocket = speech_to_text.recognize_with_websocket(
+  audio: audio_file,
+  recognize_callback: callback,
+  interim_results: true
+)
+thr = Thread.new do # Start the websocket inside of a thread
+  websocket.start # Starts the websocket and begins sending audio to the server.
+  # The `callback` processes the data from the server
+end
+thr.join # Wait for the thread to finish before ending the program or running other code
+```
+
+## Ruby version
+
+Tested on Ruby 2.3, 2.4, 2.5
+
+## Contributing
+
+See [CONTRIBUTING.md][CONTRIBUTING].
+
+## License
+
+This library is licensed under the [Apache 2.0 license][license].
+
+[wdc]: http://www.ibm.com/watson/developercloud/
+[ibm_cloud]: https://console.bluemix.net
+[watson-dashboard]: https://console.bluemix.net/dashboard/apps?category=watson
+[examples]: https://github.com/watson-developer-cloud/ruby-sdk/tree/master/examples
+[CONTRIBUTING]: https://github.com/watson-developer-cloud/ruby-sdk/blob/master/CONTRIBUTING.md
+[license]: http://www.apache.org/licenses/LICENSE-2.0
+[vcap_services]: https://console.bluemix.net/docs/services/watson/getting-started-variables.html
+[ibm-cloud-onboarding]: http://console.bluemix.net/registration?target=/developer/watson&cm_sp=WatsonPlatform-WatsonServices-_-OnPageNavLink-IBMWatson_SDKs-_-Ruby
+[ivar]: http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ibm_watson"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ibm_watson.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Module for the Watson APIs
+module IBMWatson
+  require_relative("./ibm_watson/personality_insights_v3.rb")
+  require_relative("./ibm_watson/tone_analyzer_v3.rb")
+  require_relative("./ibm_watson/assistant_v1.rb")
+  require_relative("./ibm_watson/text_to_speech_v1.rb")
+  require_relative("./ibm_watson/discovery_v1.rb")
+  require_relative("./ibm_watson/natural_language_understanding_v1.rb")
+  require_relative("./ibm_watson/speech_to_text_v1.rb")
+  require_relative("./ibm_watson/visual_recognition_v3.rb")
+  require_relative("./ibm_watson/natural_language_classifier_v1.rb")
+  require_relative("./ibm_watson/language_translator_v3.rb")
+  require_relative("./ibm_watson/websocket/recognize_callback.rb")
+end

data/lib/ibm_watson/assistant_v1.rb

@@ -0,0 +1,1997 @@
+# frozen_string_literal: true
+
+# Copyright 2018 IBM All Rights Reserved.
+#
+# 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.
+
+# The IBM Watson™ Assistant service combines machine learning, natural language
+# understanding, and integrated dialog tools to create conversation flows between your
+# apps and your users.
+
+require "concurrent"
+require "erb"
+require "json"
+require_relative "./detailed_response"
+
+require_relative "./watson_service"
+
+module IBMWatson
+  ##
+  # The Assistant V1 service.
+  class AssistantV1
+    include Concurrent::Async
+    ##
+    # @!method initialize(args)
+    # Construct a new client for the Assistant service.
+    #
+    # @param args [Hash] The args to initialize with
+    # @option args version [String] The API version date to use with the service, in
+    #   "YYYY-MM-DD" format. Whenever the API is changed in a backwards
+    #   incompatible way, a new minor version of the API is released.
+    #   The service uses the API version for the date you specify, or
+    #   the most recent version before that date. Note that you should
+    #   not programmatically specify the current date at runtime, in
+    #   case the API has been updated since your application's release.
+    #   Instead, specify a version date that is compatible with your
+    #   application, and don't change it until your application is
+    #   ready for a later version.
+    # @option args url [String] The base url to use when contacting the service (e.g.
+    #   "https://gateway.watsonplatform.net/assistant/api").
+    #   The base url may differ between Bluemix regions.
+    # @option args username [String] The username used to authenticate with the service.
+    #   Username and password credentials are only required to run your
+    #   application locally or outside of Bluemix. When running on
+    #   Bluemix, the credentials will be automatically loaded from the
+    #   `VCAP_SERVICES` environment variable.
+    # @option args password [String] The password used to authenticate with the service.
+    #   Username and password credentials are only required to run your
+    #   application locally or outside of Bluemix. When running on
+    #   Bluemix, the credentials will be automatically loaded from the
+    #   `VCAP_SERVICES` environment variable.
+    # @option args iam_api_key [String] An API key that can be used to request IAM tokens. If
+    #   this API key is provided, the SDK will manage the token and handle the
+    #   refreshing.
+    # @option args iam_access_token [String] An IAM access token is fully managed by the application.
+    #   Responsibility falls on the application to refresh the token, either before
+    #   it expires or reactively upon receiving a 401 from the service as any requests
+    #   made with an expired token will fail.
+    # @option args iam_url [String] An optional URL for the IAM service API. Defaults to
+    #   'https://iam.ng.bluemix.net/identity/token'.
+    def initialize(args = {})
+      @__async_initialized__ = false
+      super()
+      defaults = {}
+      defaults[:version] = nil
+      defaults[:url] = "https://gateway.watsonplatform.net/assistant/api"
+      defaults[:username] = nil
+      defaults[:password] = nil
+      defaults[:iam_api_key] = nil
+      defaults[:iam_access_token] = nil
+      defaults[:iam_url] = nil
+      args = defaults.merge(args)
+      @watson_service = WatsonService.new(
+        vcap_services_name: "conversation",
+        url: args[:url],
+        username: args[:username],
+        password: args[:password],
+        iam_api_key: args[:iam_api_key],
+        iam_access_token: args[:iam_access_token],
+        iam_url: args[:iam_url],
+        use_vcap_services: true
+      )
+      @version = args[:version]
+    end
+
+    # :nocov:
+    def add_default_headers(headers: {})
+      @watson_service.add_default_headers(headers: headers)
+    end
+
+    def _iam_access_token(iam_access_token:)
+      @watson_service._iam_access_token(iam_access_token: iam_access_token)
+    end
+
+    def _iam_api_key(iam_api_key:)
+      @watson_service._iam_api_key(iam_api_key: iam_api_key)
+    end
+
+    # @return [DetailedResponse]
+    def request(args)
+      @watson_service.request(args)
+    end
+
+    # @note Chainable
+    # @param headers [Hash] Custom headers to be sent with the request
+    # @return [self]
+    def headers(headers)
+      @watson_service.headers(headers)
+      self
+    end
+
+    def password=(password)
+      @watson_service.password = password
+    end
+
+    def password
+      @watson_service.password
+    end
+
+    def username=(username)
+      @watson_service.username = username
+    end
+
+    def username
+      @watson_service.username
+    end
+
+    def url=(url)
+      @watson_service.url = url
+    end
+
+    def url
+      @watson_service.url
+    end
+    # :nocov:
+    #########################
+    # Message
+    #########################
+
+    ##
+    # @!method message(workspace_id:, input: nil, alternate_intents: nil, context: nil, entities: nil, intents: nil, output: nil, nodes_visited_details: nil)
+    # Get response to user input.
+    # Get a response to a user's input.
+    #
+    #   There is no rate limit for this operation.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param input [InputData] An input object that includes the input text.
+    # @param alternate_intents [Boolean] Whether to return more than one intent. Set to `true` to return all matching
+    #   intents.
+    # @param context [Context] State information for the conversation. Continue a conversation by including the
+    #   context object from the previous response.
+    # @param entities [Array[RuntimeEntity]] Entities to use when evaluating the message. Include entities from the previous
+    #   response to continue using those entities rather than detecting entities in the
+    #   new input.
+    # @param intents [Array[RuntimeIntent]] Intents to use when evaluating the user input. Include intents from the previous
+    #   response to continue using those intents rather than trying to recognize intents
+    #   in the new input.
+    # @param output [OutputData] System output. Include the output from the previous response to maintain
+    #   intermediate information over multiple requests.
+    # @param nodes_visited_details [Boolean] Whether to include additional diagnostic information about the dialog nodes that
+    #   were visited during processing of the message.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def message(workspace_id:, input: nil, alternate_intents: nil, context: nil, entities: nil, intents: nil, output: nil, nodes_visited_details: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "nodes_visited_details" => nodes_visited_details
+      }
+      data = {
+        "input" => input,
+        "alternate_intents" => alternate_intents,
+        "context" => context,
+        "entities" => entities,
+        "intents" => intents,
+        "output" => output
+      }
+      method_url = "/v1/workspaces/%s/message" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+    #########################
+    # Workspaces
+    #########################
+
+    ##
+    # @!method list_workspaces(page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List workspaces.
+    # List the workspaces associated with a Watson Assistant service instance.
+    #
+    #   This operation is limited to 500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_workspaces(page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces"
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_workspace(name: nil, description: nil, language: nil, intents: nil, entities: nil, dialog_nodes: nil, counterexamples: nil, metadata: nil, learning_opt_out: nil)
+    # Create workspace.
+    # Create a workspace based on component objects. You must provide workspace
+    #   components defining the content of the new workspace.
+    #
+    #   This operation is limited to 30 requests per 30 minutes. For more information, see
+    #   **Rate limiting**.
+    # @param name [String] The name of the workspace. This string cannot contain carriage return, newline, or
+    #   tab characters, and it must be no longer than 64 characters.
+    # @param description [String] The description of the workspace. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param language [String] The language of the workspace.
+    # @param intents [Array[CreateIntent]] An array of objects defining the intents for the workspace.
+    # @param entities [Array[CreateEntity]] An array of objects defining the entities for the workspace.
+    # @param dialog_nodes [Array[CreateDialogNode]] An array of objects defining the nodes in the workspace dialog.
+    # @param counterexamples [Array[CreateCounterexample]] An array of objects defining input examples that have been marked as irrelevant
+    #   input.
+    # @param metadata [Object] Any metadata related to the workspace.
+    # @param learning_opt_out [Boolean] Whether training data from the workspace can be used by IBM for general service
+    #   improvements. `true` indicates that workspace training data is not to be used.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_workspace(name: nil, description: nil, language: nil, intents: nil, entities: nil, dialog_nodes: nil, counterexamples: nil, metadata: nil, learning_opt_out: nil)
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "name" => name,
+        "description" => description,
+        "language" => language,
+        "intents" => intents,
+        "entities" => entities,
+        "dialog_nodes" => dialog_nodes,
+        "counterexamples" => counterexamples,
+        "metadata" => metadata,
+        "learning_opt_out" => learning_opt_out
+      }
+      method_url = "/v1/workspaces"
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_workspace(workspace_id:, export: nil, include_audit: nil)
+    # Get information about a workspace.
+    # Get information about a workspace, optionally including all workspace content.
+    #
+    #   With **export**=`false`, this operation is limited to 6000 requests per 5 minutes.
+    #   With **export**=`true`, the limit is 20 requests per 30 minutes. For more
+    #   information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_workspace(workspace_id:, export: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_workspace(workspace_id:, name: nil, description: nil, language: nil, intents: nil, entities: nil, dialog_nodes: nil, counterexamples: nil, metadata: nil, learning_opt_out: nil, append: nil)
+    # Update workspace.
+    # Update an existing workspace with new or modified data. You must provide component
+    #   objects defining the content of the updated workspace.
+    #
+    #   This operation is limited to 30 request per 30 minutes. For more information, see
+    #   **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param name [String] The name of the workspace. This string cannot contain carriage return, newline, or
+    #   tab characters, and it must be no longer than 64 characters.
+    # @param description [String] The description of the workspace. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param language [String] The language of the workspace.
+    # @param intents [Array[CreateIntent]] An array of objects defining the intents for the workspace.
+    # @param entities [Array[CreateEntity]] An array of objects defining the entities for the workspace.
+    # @param dialog_nodes [Array[CreateDialogNode]] An array of objects defining the nodes in the workspace dialog.
+    # @param counterexamples [Array[CreateCounterexample]] An array of objects defining input examples that have been marked as irrelevant
+    #   input.
+    # @param metadata [Object] Any metadata related to the workspace.
+    # @param learning_opt_out [Boolean] Whether training data from the workspace can be used by IBM for general service
+    #   improvements. `true` indicates that workspace training data is not to be used.
+    # @param append [Boolean] Whether the new data is to be appended to the existing data in the workspace. If
+    #   **append**=`false`, elements included in the new data completely replace the
+    #   corresponding existing elements, including all subelements. For example, if the
+    #   new data includes **entities** and **append**=`false`, all existing entities in
+    #   the workspace are discarded and replaced with the new entities.
+    #
+    #   If **append**=`true`, existing elements are preserved, and the new elements are
+    #   added. If any elements in the new data collide with existing elements, the update
+    #   request fails.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_workspace(workspace_id:, name: nil, description: nil, language: nil, intents: nil, entities: nil, dialog_nodes: nil, counterexamples: nil, metadata: nil, learning_opt_out: nil, append: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "append" => append
+      }
+      data = {
+        "name" => name,
+        "description" => description,
+        "language" => language,
+        "intents" => intents,
+        "entities" => entities,
+        "dialog_nodes" => dialog_nodes,
+        "counterexamples" => counterexamples,
+        "metadata" => metadata,
+        "learning_opt_out" => learning_opt_out
+      }
+      method_url = "/v1/workspaces/%s" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_workspace(workspace_id:)
+    # Delete workspace.
+    # Delete a workspace from the service instance.
+    #
+    #   This operation is limited to 30 requests per 30 minutes. For more information, see
+    #   **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @return [nil]
+    def delete_workspace(workspace_id:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s" % [ERB::Util.url_encode(workspace_id)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Intents
+    #########################
+
+    ##
+    # @!method list_intents(workspace_id:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List intents.
+    # List the intents for a workspace.
+    #
+    #   With **export**=`false`, this operation is limited to 2000 requests per 30
+    #   minutes. With **export**=`true`, the limit is 400 requests per 30 minutes. For
+    #   more information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_intents(workspace_id:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/intents" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_intent(workspace_id:, intent:, description: nil, examples: nil)
+    # Create intent.
+    # Create a new intent.
+    #
+    #   This operation is limited to 2000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The name of the intent. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, underscore, hyphen, and dot
+    #   characters.
+    #   - It cannot begin with the reserved prefix `sys-`.
+    #   - It must be no longer than 128 characters.
+    # @param description [String] The description of the intent. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param examples [Array[CreateExample]] An array of user input examples for the intent.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_intent(workspace_id:, intent:, description: nil, examples: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "intent" => intent,
+        "description" => description,
+        "examples" => examples
+      }
+      method_url = "/v1/workspaces/%s/intents" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_intent(workspace_id:, intent:, export: nil, include_audit: nil)
+    # Get intent.
+    # Get information about an intent, optionally including all intent content.
+    #
+    #   With **export**=`false`, this operation is limited to 6000 requests per 5 minutes.
+    #   With **export**=`true`, the limit is 400 requests per 30 minutes. For more
+    #   information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_intent(workspace_id:, intent:, export: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/intents/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_intent(workspace_id:, intent:, new_intent: nil, new_description: nil, new_examples: nil)
+    # Update intent.
+    # Update an existing intent with new or modified data. You must provide component
+    #   objects defining the content of the updated intent.
+    #
+    #   This operation is limited to 2000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param new_intent [String] The name of the intent. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, underscore, hyphen, and dot
+    #   characters.
+    #   - It cannot begin with the reserved prefix `sys-`.
+    #   - It must be no longer than 128 characters.
+    # @param new_description [String] The description of the intent.
+    # @param new_examples [Array[CreateExample]] An array of user input examples for the intent.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_intent(workspace_id:, intent:, new_intent: nil, new_description: nil, new_examples: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "intent" => new_intent,
+        "description" => new_description,
+        "examples" => new_examples
+      }
+      method_url = "/v1/workspaces/%s/intents/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_intent(workspace_id:, intent:)
+    # Delete intent.
+    # Delete an intent from a workspace.
+    #
+    #   This operation is limited to 2000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @return [nil]
+    def delete_intent(workspace_id:, intent:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/intents/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Examples
+    #########################
+
+    ##
+    # @!method list_examples(workspace_id:, intent:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List user input examples.
+    # List the user input examples for an intent.
+    #
+    #   This operation is limited to 2500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_examples(workspace_id:, intent:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/intents/%s/examples" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_example(workspace_id:, intent:, text:)
+    # Create user input example.
+    # Add a new user input example to an intent.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param text [String] The text of a user input example. This string must conform to the following
+    #   restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 1024 characters.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_example(workspace_id:, intent:, text:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "text" => text
+      }
+      method_url = "/v1/workspaces/%s/intents/%s/examples" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_example(workspace_id:, intent:, text:, include_audit: nil)
+    # Get user input example.
+    # Get information about a user input example.
+    #
+    #   This operation is limited to 6000 requests per 5 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param text [String] The text of the user input example.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_example(workspace_id:, intent:, text:, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/intents/%s/examples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent), ERB::Util.url_encode(text)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_example(workspace_id:, intent:, text:, new_text: nil)
+    # Update user input example.
+    # Update the text of a user input example.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param text [String] The text of the user input example.
+    # @param new_text [String] The text of the user input example. This string must conform to the following
+    #   restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 1024 characters.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_example(workspace_id:, intent:, text:, new_text: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "text" => new_text
+      }
+      method_url = "/v1/workspaces/%s/intents/%s/examples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent), ERB::Util.url_encode(text)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_example(workspace_id:, intent:, text:)
+    # Delete user input example.
+    # Delete a user input example from an intent.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param intent [String] The intent name.
+    # @param text [String] The text of the user input example.
+    # @return [nil]
+    def delete_example(workspace_id:, intent:, text:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("intent must be provided") if intent.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/intents/%s/examples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(intent), ERB::Util.url_encode(text)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Counterexamples
+    #########################
+
+    ##
+    # @!method list_counterexamples(workspace_id:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List counterexamples.
+    # List the counterexamples for a workspace. Counterexamples are examples that have
+    #   been marked as irrelevant input.
+    #
+    #   This operation is limited to 2500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_counterexamples(workspace_id:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/counterexamples" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_counterexample(workspace_id:, text:)
+    # Create counterexample.
+    # Add a new counterexample to a workspace. Counterexamples are examples that have
+    #   been marked as irrelevant input.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param text [String] The text of a user input marked as irrelevant input. This string must conform to
+    #   the following restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters
+    #   - It cannot consist of only whitespace characters
+    #   - It must be no longer than 1024 characters.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_counterexample(workspace_id:, text:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "text" => text
+      }
+      method_url = "/v1/workspaces/%s/counterexamples" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_counterexample(workspace_id:, text:, include_audit: nil)
+    # Get counterexample.
+    # Get information about a counterexample. Counterexamples are examples that have
+    #   been marked as irrelevant input.
+    #
+    #   This operation is limited to 6000 requests per 5 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param text [String] The text of a user input counterexample (for example, `What are you wearing?`).
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_counterexample(workspace_id:, text:, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/counterexamples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(text)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_counterexample(workspace_id:, text:, new_text: nil)
+    # Update counterexample.
+    # Update the text of a counterexample. Counterexamples are examples that have been
+    #   marked as irrelevant input.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param text [String] The text of a user input counterexample (for example, `What are you wearing?`).
+    # @param new_text [String] The text of a user input counterexample.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_counterexample(workspace_id:, text:, new_text: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "text" => new_text
+      }
+      method_url = "/v1/workspaces/%s/counterexamples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(text)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_counterexample(workspace_id:, text:)
+    # Delete counterexample.
+    # Delete a counterexample from a workspace. Counterexamples are examples that have
+    #   been marked as irrelevant input.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param text [String] The text of a user input counterexample (for example, `What are you wearing?`).
+    # @return [nil]
+    def delete_counterexample(workspace_id:, text:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("text must be provided") if text.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/counterexamples/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(text)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Entities
+    #########################
+
+    ##
+    # @!method list_entities(workspace_id:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List entities.
+    # List the entities for a workspace.
+    #
+    #   With **export**=`false`, this operation is limited to 1000 requests per 30
+    #   minutes. With **export**=`true`, the limit is 200 requests per 30 minutes. For
+    #   more information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_entities(workspace_id:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_entity(workspace_id:, entity:, description: nil, metadata: nil, values: nil, fuzzy_match: nil)
+    # Create entity.
+    # Create a new entity.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, underscore, and hyphen characters.
+    #   - It cannot begin with the reserved prefix `sys-`.
+    #   - It must be no longer than 64 characters.
+    # @param description [String] The description of the entity. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param metadata [Object] Any metadata related to the value.
+    # @param values [Array[CreateValue]] An array of objects describing the entity values.
+    # @param fuzzy_match [Boolean] Whether to use fuzzy matching for the entity.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_entity(workspace_id:, entity:, description: nil, metadata: nil, values: nil, fuzzy_match: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "entity" => entity,
+        "description" => description,
+        "metadata" => metadata,
+        "values" => values,
+        "fuzzy_match" => fuzzy_match
+      }
+      method_url = "/v1/workspaces/%s/entities" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_entity(workspace_id:, entity:, export: nil, include_audit: nil)
+    # Get entity.
+    # Get information about an entity, optionally including all entity content.
+    #
+    #   With **export**=`false`, this operation is limited to 6000 requests per 5 minutes.
+    #   With **export**=`true`, the limit is 200 requests per 30 minutes. For more
+    #   information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_entity(workspace_id:, entity:, export: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_entity(workspace_id:, entity:, new_entity: nil, new_description: nil, new_metadata: nil, new_fuzzy_match: nil, new_values: nil)
+    # Update entity.
+    # Update an existing entity with new or modified data. You must provide component
+    #   objects defining the content of the updated entity.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param new_entity [String] The name of the entity. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, underscore, and hyphen characters.
+    #   - It cannot begin with the reserved prefix `sys-`.
+    #   - It must be no longer than 64 characters.
+    # @param new_description [String] The description of the entity. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param new_metadata [Object] Any metadata related to the entity.
+    # @param new_fuzzy_match [Boolean] Whether to use fuzzy matching for the entity.
+    # @param new_values [Array[CreateValue]] An array of entity values.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_entity(workspace_id:, entity:, new_entity: nil, new_description: nil, new_metadata: nil, new_fuzzy_match: nil, new_values: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "entity" => new_entity,
+        "description" => new_description,
+        "metadata" => new_metadata,
+        "fuzzy_match" => new_fuzzy_match,
+        "values" => new_values
+      }
+      method_url = "/v1/workspaces/%s/entities/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_entity(workspace_id:, entity:)
+    # Delete entity.
+    # Delete an entity from a workspace.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @return [nil]
+    def delete_entity(workspace_id:, entity:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/entities/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Values
+    #########################
+
+    ##
+    # @!method list_values(workspace_id:, entity:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List entity values.
+    # List the values for an entity.
+    #
+    #   This operation is limited to 2500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_values(workspace_id:, entity:, export: nil, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_value(workspace_id:, entity:, value:, metadata: nil, synonyms: nil, patterns: nil, value_type: nil)
+    # Add entity value.
+    # Create a new value for an entity.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value. This string must conform to the following
+    #   restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @param metadata [Object] Any metadata related to the entity value.
+    # @param synonyms [Array[String]] An array containing any synonyms for the entity value. You can provide either
+    #   synonyms or patterns (as indicated by **type**), but not both. A synonym must
+    #   conform to the following restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @param patterns [Array[String]] An array of patterns for the entity value. You can provide either synonyms or
+    #   patterns (as indicated by **type**), but not both. A pattern is a regular
+    #   expression no longer than 512 characters. For more information about how to
+    #   specify a pattern, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/entities.html#creating-entities).
+    # @param value_type [String] Specifies the type of value.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_value(workspace_id:, entity:, value:, metadata: nil, synonyms: nil, patterns: nil, value_type: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "value" => value,
+        "metadata" => metadata,
+        "synonyms" => synonyms,
+        "patterns" => patterns,
+        "type" => value_type
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_value(workspace_id:, entity:, value:, export: nil, include_audit: nil)
+    # Get entity value.
+    # Get information about an entity value.
+    #
+    #   This operation is limited to 6000 requests per 5 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param export [Boolean] Whether to include all element content in the returned data. If
+    #   **export**=`false`, the returned data includes only information about the element
+    #   itself. If **export**=`true`, all content, including subelements, is included.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_value(workspace_id:, entity:, value:, export: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "export" => export,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_value(workspace_id:, entity:, value:, new_value: nil, new_metadata: nil, new_type: nil, new_synonyms: nil, new_patterns: nil)
+    # Update entity value.
+    # Update an existing entity value with new or modified data. You must provide
+    #   component objects defining the content of the updated entity value.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param new_value [String] The text of the entity value. This string must conform to the following
+    #   restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @param new_metadata [Object] Any metadata related to the entity value.
+    # @param new_type [String] Specifies the type of value.
+    # @param new_synonyms [Array[String]] An array of synonyms for the entity value. You can provide either synonyms or
+    #   patterns (as indicated by **type**), but not both. A synonym must conform to the
+    #   following resrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @param new_patterns [Array[String]] An array of patterns for the entity value. You can provide either synonyms or
+    #   patterns (as indicated by **type**), but not both. A pattern is a regular
+    #   expression no longer than 512 characters. For more information about how to
+    #   specify a pattern, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/entities.html#creating-entities).
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_value(workspace_id:, entity:, value:, new_value: nil, new_metadata: nil, new_type: nil, new_synonyms: nil, new_patterns: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "value" => new_value,
+        "metadata" => new_metadata,
+        "type" => new_type,
+        "synonyms" => new_synonyms,
+        "patterns" => new_patterns
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_value(workspace_id:, entity:, value:)
+    # Delete entity value.
+    # Delete a value from an entity.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @return [nil]
+    def delete_value(workspace_id:, entity:, value:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Synonyms
+    #########################
+
+    ##
+    # @!method list_synonyms(workspace_id:, entity:, value:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List entity value synonyms.
+    # List the synonyms for an entity value.
+    #
+    #   This operation is limited to 2500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_synonyms(workspace_id:, entity:, value:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s/synonyms" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_synonym(workspace_id:, entity:, value:, synonym:)
+    # Add entity value synonym.
+    # Add a new synonym to an entity value.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param synonym [String] The text of the synonym. This string must conform to the following restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_synonym(workspace_id:, entity:, value:, synonym:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      raise ArgumentError("synonym must be provided") if synonym.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "synonym" => synonym
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s/synonyms" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_synonym(workspace_id:, entity:, value:, synonym:, include_audit: nil)
+    # Get entity value synonym.
+    # Get information about a synonym of an entity value.
+    #
+    #   This operation is limited to 6000 requests per 5 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param synonym [String] The text of the synonym.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_synonym(workspace_id:, entity:, value:, synonym:, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      raise ArgumentError("synonym must be provided") if synonym.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s/synonyms/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value), ERB::Util.url_encode(synonym)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_synonym(workspace_id:, entity:, value:, synonym:, new_synonym: nil)
+    # Update entity value synonym.
+    # Update an existing entity value synonym with new text.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param synonym [String] The text of the synonym.
+    # @param new_synonym [String] The text of the synonym. This string must conform to the following restrictions:
+    #   - It cannot contain carriage return, newline, or tab characters.
+    #   - It cannot consist of only whitespace characters.
+    #   - It must be no longer than 64 characters.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_synonym(workspace_id:, entity:, value:, synonym:, new_synonym: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      raise ArgumentError("synonym must be provided") if synonym.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "synonym" => new_synonym
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s/synonyms/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value), ERB::Util.url_encode(synonym)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_synonym(workspace_id:, entity:, value:, synonym:)
+    # Delete entity value synonym.
+    # Delete a synonym from an entity value.
+    #
+    #   This operation is limited to 1000 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param entity [String] The name of the entity.
+    # @param value [String] The text of the entity value.
+    # @param synonym [String] The text of the synonym.
+    # @return [nil]
+    def delete_synonym(workspace_id:, entity:, value:, synonym:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("entity must be provided") if entity.nil?
+      raise ArgumentError("value must be provided") if value.nil?
+      raise ArgumentError("synonym must be provided") if synonym.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/entities/%s/values/%s/synonyms/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(entity), ERB::Util.url_encode(value), ERB::Util.url_encode(synonym)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Dialog nodes
+    #########################
+
+    ##
+    # @!method list_dialog_nodes(workspace_id:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+    # List dialog nodes.
+    # List the dialog nodes for a workspace.
+    #
+    #   This operation is limited to 2500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param include_count [Boolean] Whether to include information about the number of records returned.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_dialog_nodes(workspace_id:, page_limit: nil, include_count: nil, sort: nil, cursor: nil, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "page_limit" => page_limit,
+        "include_count" => include_count,
+        "sort" => sort,
+        "cursor" => cursor,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/dialog_nodes" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method create_dialog_node(workspace_id:, dialog_node:, description: nil, conditions: nil, parent: nil, previous_sibling: nil, output: nil, context: nil, metadata: nil, next_step: nil, actions: nil, title: nil, node_type: nil, event_name: nil, variable: nil, digress_in: nil, digress_out: nil, digress_out_slots: nil)
+    # Create dialog node.
+    # Create a new dialog node.
+    #
+    #   This operation is limited to 500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param dialog_node [String] The dialog node ID. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, space, underscore, hyphen, and dot
+    #   characters.
+    #   - It must be no longer than 1024 characters.
+    # @param description [String] The description of the dialog node. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param conditions [String] The condition that will trigger the dialog node. This string cannot contain
+    #   carriage return, newline, or tab characters, and it must be no longer than 2048
+    #   characters.
+    # @param parent [String] The ID of the parent dialog node.
+    # @param previous_sibling [String] The ID of the previous dialog node.
+    # @param output [Object] The output of the dialog node. For more information about how to specify dialog
+    #   node output, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/dialog-overview.html#complex).
+    # @param context [Object] The context for the dialog node.
+    # @param metadata [Object] The metadata for the dialog node.
+    # @param next_step [DialogNodeNextStep] The next step to be executed in dialog processing.
+    # @param actions [Array[DialogNodeAction]] An array of objects describing any actions to be invoked by the dialog node.
+    # @param title [String] The alias used to identify the dialog node. This string must conform to the
+    #   following restrictions:
+    #   - It can contain only Unicode alphanumeric, space, underscore, hyphen, and dot
+    #   characters.
+    #   - It must be no longer than 64 characters.
+    # @param node_type [String] How the dialog node is processed.
+    # @param event_name [String] How an `event_handler` node is processed.
+    # @param variable [String] The location in the dialog context where output is stored.
+    # @param digress_in [String] Whether this top-level dialog node can be digressed into.
+    # @param digress_out [String] Whether this dialog node can be returned to after a digression.
+    # @param digress_out_slots [String] Whether the user can digress to top-level nodes while filling out slots.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def create_dialog_node(workspace_id:, dialog_node:, description: nil, conditions: nil, parent: nil, previous_sibling: nil, output: nil, context: nil, metadata: nil, next_step: nil, actions: nil, title: nil, node_type: nil, event_name: nil, variable: nil, digress_in: nil, digress_out: nil, digress_out_slots: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("dialog_node must be provided") if dialog_node.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "dialog_node" => dialog_node,
+        "description" => description,
+        "conditions" => conditions,
+        "parent" => parent,
+        "previous_sibling" => previous_sibling,
+        "output" => output,
+        "context" => context,
+        "metadata" => metadata,
+        "next_step" => next_step,
+        "actions" => actions,
+        "title" => title,
+        "type" => node_type,
+        "event_name" => event_name,
+        "variable" => variable,
+        "digress_in" => digress_in,
+        "digress_out" => digress_out,
+        "digress_out_slots" => digress_out_slots
+      }
+      method_url = "/v1/workspaces/%s/dialog_nodes" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method get_dialog_node(workspace_id:, dialog_node:, include_audit: nil)
+    # Get dialog node.
+    # Get information about a dialog node.
+    #
+    #   This operation is limited to 6000 requests per 5 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param dialog_node [String] The dialog node ID (for example, `get_order`).
+    # @param include_audit [Boolean] Whether to include the audit properties (`created` and `updated` timestamps) in
+    #   the response.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def get_dialog_node(workspace_id:, dialog_node:, include_audit: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("dialog_node must be provided") if dialog_node.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "include_audit" => include_audit
+      }
+      method_url = "/v1/workspaces/%s/dialog_nodes/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(dialog_node)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method update_dialog_node(workspace_id:, dialog_node:, new_dialog_node: nil, new_description: nil, new_conditions: nil, new_parent: nil, new_previous_sibling: nil, new_output: nil, new_context: nil, new_metadata: nil, new_next_step: nil, new_title: nil, new_type: nil, new_event_name: nil, new_variable: nil, new_actions: nil, new_digress_in: nil, new_digress_out: nil, new_digress_out_slots: nil)
+    # Update dialog node.
+    # Update an existing dialog node with new or modified data.
+    #
+    #   This operation is limited to 500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param dialog_node [String] The dialog node ID (for example, `get_order`).
+    # @param new_dialog_node [String] The dialog node ID. This string must conform to the following restrictions:
+    #   - It can contain only Unicode alphanumeric, space, underscore, hyphen, and dot
+    #   characters.
+    #   - It must be no longer than 1024 characters.
+    # @param new_description [String] The description of the dialog node. This string cannot contain carriage return,
+    #   newline, or tab characters, and it must be no longer than 128 characters.
+    # @param new_conditions [String] The condition that will trigger the dialog node. This string cannot contain
+    #   carriage return, newline, or tab characters, and it must be no longer than 2048
+    #   characters.
+    # @param new_parent [String] The ID of the parent dialog node.
+    # @param new_previous_sibling [String] The ID of the previous sibling dialog node.
+    # @param new_output [Object] The output of the dialog node. For more information about how to specify dialog
+    #   node output, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/dialog-overview.html#complex).
+    # @param new_context [Object] The context for the dialog node.
+    # @param new_metadata [Object] The metadata for the dialog node.
+    # @param new_next_step [DialogNodeNextStep] The next step to be executed in dialog processing.
+    # @param new_title [String] The alias used to identify the dialog node. This string must conform to the
+    #   following restrictions:
+    #   - It can contain only Unicode alphanumeric, space, underscore, hyphen, and dot
+    #   characters.
+    #   - It must be no longer than 64 characters.
+    # @param new_type [String] How the dialog node is processed.
+    # @param new_event_name [String] How an `event_handler` node is processed.
+    # @param new_variable [String] The location in the dialog context where output is stored.
+    # @param new_actions [Array[DialogNodeAction]] An array of objects describing any actions to be invoked by the dialog node.
+    # @param new_digress_in [String] Whether this top-level dialog node can be digressed into.
+    # @param new_digress_out [String] Whether this dialog node can be returned to after a digression.
+    # @param new_digress_out_slots [String] Whether the user can digress to top-level nodes while filling out slots.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def update_dialog_node(workspace_id:, dialog_node:, new_dialog_node: nil, new_description: nil, new_conditions: nil, new_parent: nil, new_previous_sibling: nil, new_output: nil, new_context: nil, new_metadata: nil, new_next_step: nil, new_title: nil, new_type: nil, new_event_name: nil, new_variable: nil, new_actions: nil, new_digress_in: nil, new_digress_out: nil, new_digress_out_slots: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("dialog_node must be provided") if dialog_node.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      data = {
+        "dialog_node" => new_dialog_node,
+        "description" => new_description,
+        "conditions" => new_conditions,
+        "parent" => new_parent,
+        "previous_sibling" => new_previous_sibling,
+        "output" => new_output,
+        "context" => new_context,
+        "metadata" => new_metadata,
+        "next_step" => new_next_step,
+        "title" => new_title,
+        "type" => new_type,
+        "event_name" => new_event_name,
+        "variable" => new_variable,
+        "actions" => new_actions,
+        "digress_in" => new_digress_in,
+        "digress_out" => new_digress_out,
+        "digress_out_slots" => new_digress_out_slots
+      }
+      method_url = "/v1/workspaces/%s/dialog_nodes/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(dialog_node)]
+      response = request(
+        method: "POST",
+        url: method_url,
+        headers: headers,
+        params: params,
+        json: data,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method delete_dialog_node(workspace_id:, dialog_node:)
+    # Delete dialog node.
+    # Delete a dialog node from a workspace.
+    #
+    #   This operation is limited to 500 requests per 30 minutes. For more information,
+    #   see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param dialog_node [String] The dialog node ID (for example, `get_order`).
+    # @return [nil]
+    def delete_dialog_node(workspace_id:, dialog_node:)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      raise ArgumentError("dialog_node must be provided") if dialog_node.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version
+      }
+      method_url = "/v1/workspaces/%s/dialog_nodes/%s" % [ERB::Util.url_encode(workspace_id), ERB::Util.url_encode(dialog_node)]
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+    #########################
+    # Logs
+    #########################
+
+    ##
+    # @!method list_logs(workspace_id:, sort: nil, filter: nil, page_limit: nil, cursor: nil)
+    # List log events in a workspace.
+    # List the events from the log of a specific workspace.
+    #
+    #   If **cursor** is not specified, this operation is limited to 40 requests per 30
+    #   minutes. If **cursor** is specified, the limit is 120 requests per minute. For
+    #   more information, see **Rate limiting**.
+    # @param workspace_id [String] Unique identifier of the workspace.
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param filter [String] A cacheable parameter that limits the results to those matching the specified
+    #   filter. For more information, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/filter-reference.html#filter-query-syntax).
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_logs(workspace_id:, sort: nil, filter: nil, page_limit: nil, cursor: nil)
+      raise ArgumentError("workspace_id must be provided") if workspace_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "sort" => sort,
+        "filter" => filter,
+        "page_limit" => page_limit,
+        "cursor" => cursor
+      }
+      method_url = "/v1/workspaces/%s/logs" % [ERB::Util.url_encode(workspace_id)]
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+
+    ##
+    # @!method list_all_logs(filter:, sort: nil, page_limit: nil, cursor: nil)
+    # List log events in all workspaces.
+    # List the events from the logs of all workspaces in the service instance.
+    #
+    #   If **cursor** is not specified, this operation is limited to 40 requests per 30
+    #   minutes. If **cursor** is specified, the limit is 120 requests per minute. For
+    #   more information, see **Rate limiting**.
+    # @param filter [String] A cacheable parameter that limits the results to those matching the specified
+    #   filter. You must specify a filter query that includes a value for `language`, as
+    #   well as a value for `workspace_id` or `request.context.metadata.deployment`. For
+    #   more information, see the
+    #   [documentation](https://console.bluemix.net/docs/services/conversation/filter-reference.html#filter-query-syntax).
+    # @param sort [String] The attribute by which returned results will be sorted. To reverse the sort order,
+    #   prefix the value with a minus sign (`-`). Supported values are `name`, `updated`,
+    #   and `workspace_id`.
+    # @param page_limit [Fixnum] The number of records to return in each page of results.
+    # @param cursor [String] A token identifying the page of results to retrieve.
+    # @return [DetailedResponse] A `DetailedResponse` object representing the response.
+    def list_all_logs(filter:, sort: nil, page_limit: nil, cursor: nil)
+      raise ArgumentError("filter must be provided") if filter.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "filter" => filter,
+        "sort" => sort,
+        "page_limit" => page_limit,
+        "cursor" => cursor
+      }
+      method_url = "/v1/logs"
+      response = request(
+        method: "GET",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      response
+    end
+    #########################
+    # User data
+    #########################
+
+    ##
+    # @!method delete_user_data(customer_id:)
+    # Delete labeled data.
+    # Deletes all data associated with a specified customer ID. The method has no effect
+    #   if no data is associated with the customer ID.
+    #
+    #   You associate a customer ID with data by passing the `X-Watson-Metadata` header
+    #   with a request that passes data. For more information about personal data and
+    #   customer IDs, see [Information
+    #   security](https://console.bluemix.net/docs/services/conversation/information-security.html).
+    # @param customer_id [String] The customer ID for which all data is to be deleted.
+    # @return [nil]
+    def delete_user_data(customer_id:)
+      raise ArgumentError("customer_id must be provided") if customer_id.nil?
+      headers = {
+      }
+      params = {
+        "version" => @version,
+        "customer_id" => customer_id
+      }
+      method_url = "/v1/user_data"
+      request(
+        method: "DELETE",
+        url: method_url,
+        headers: headers,
+        params: params,
+        accept_json: true
+      )
+      nil
+    end
+  end
+end