<dependency>
  <groupId>com.ibm.watson</groupId>
  <artifactId>ibm-watson</artifactId>
  <version>13.0.0</version>
</dependency>

compile 'com.ibm.watson:ibm-watson:13.0.0'

npm install ibm-watson@^9.1.0

pip install --upgrade "ibm-watson>=8.1.0"

gem install ibm_watson

go get -u github.com/watson-developer-cloud/go-sdk/v2@v3.0.0

pod 'IBMWatsonAssistantV2', '~> 5.0.0'

github "watson-developer-cloud/swift-sdk" ~> 5.0.0

.package(url: "https://github.com/watson-developer-cloud/swift-sdk", from: "5.0.0")

Install-Package IBM.Watson.Assistant.v2 -Version 7.0.0

dotnet add package IBM.Watson.Assistant.v2 --version 7.0.0

<PackageReference Include="IBM.Watson.Assistant.v2" Version="7.0.0" />

curl -X {request_method} -u "apikey:{apikey}" "https://api.us-south.assistant.watson.cloud.ibm.com/instances/{instance_id}"

https://api.us-south.assistant.watson.cloud.ibm.com

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
Assistant assistant = new Assistant("{version}", authenticator);
assistant.setServiceUrl("https://api.us-east.assistant.watson.cloud.ibm.com");

https://api.us-south.assistant.watson.cloud.ibm.com

const AssistantV2 = require('ibm-watson/assistant/v2');
const { IamAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: 'https://api.us-east.assistant.watson.cloud.ibm.com',
});

https://api.us-south.assistant.watson.cloud.ibm.com

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('https://api.us-east.assistant.watson.cloud.ibm.com')

https://api.us-south.assistant.watson.cloud.ibm.com

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "https://api.us-east.assistant.watson.cloud.ibm.com"

https://api.us-south.assistant.watson.cloud.ibm.com

assistant, assistantErr := assistantv2.NewAssistantV2(options)

if assistantErr != nil {
  panic(assistantErr)
}

assistant.SetServiceURL("https://api.us-east.assistant.watson.cloud.ibm.com")

https://api.us-south.assistant.watson.cloud.ibm.com

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "https://api.us-east.assistant.watson.cloud.ibm.com"

https://api.us-south.assistant.watson.cloud.ibm.com

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://api.us-east.assistant.watson.cloud.ibm.com");

https://api.us-south.assistant.watson.cloud.ibm.com

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://api.us-east.assistant.watson.cloud.ibm.com");

curl -X {request_method} -H "Authorization: Bearer {token}" "https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api"

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator("https://{cpd_cluster_host}{:port}", "{username}", "{password}");
Assistant assistant = new Assistant("{version}", authenticator);
assistant.setServiceUrl("https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api");

const AssistantV2 = require('ibm-watson/assistant/v2');
const { CloudPakForDataAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new CloudPakForDataAuthenticator({
    username: '{username}',
    password: '{password}',
    url: 'https://{cpd_cluster_host}{:port}',
  }),
  serviceUrl: 'https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api',
});

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator

authenticator = CloudPakForDataAuthenticator(
    '{username}',
    '{password}',
    'https://{cpd_cluster_host}{:port}'
)

assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api')

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::CLoudPakForDataAuthenticator.new(
  username: "{username}",
  password: "{password}",
  url: "https://{cpd_cluster_host}{:port}"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api"

assistant, assistantErr := assistantv2.NewAssistantV2(options)

if assistantErr != nil {
  panic(assistantErr)
}

assistant.SetServiceURL("https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api")

let authenticator = CloudPakForDataAuthenticator(username: "{username}", password: "{password}", url: "https://{cpd_cluster_host}{:port}")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api"

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api");

var authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://{cpd_cluster_host}{:port}/assistant/{deployment_id}/instances/{instance_id}/api");

curl -k -X {request_method} -u "apikey:{apikey}" "{url}/{method}"

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
Assistant assistant = new Assistant("{version}", authenticator);
assistant.setServiceUrl("{url}");

HttpConfigOptions configOptions = new HttpConfigOptions.Builder()
  .disableSslVerification(true)
  .build();
assistant.configureClient(configOptions);

const AssistantV2 = require('ibm-watson/assistant/v2');
const { IamAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
  disableSslVerification: true,
});

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('{url}')

assistant.set_disable_ssl_verification(True)

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "{url}"

assistant.configure_http_client(disable_ssl_verification: true)

assistant, assistantErr := assistantv2.NewAssistantV2(options)

if assistantErr != nil {
  panic(assistantErr)
}

assistant.SetServiceURL("{url}")

assistant.DisableSSLVerification()

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "{url}"

assistant.disableSSLVerification()

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.DisableSslVerification(true);

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.DisableSslVerification = true;

curl -k -X {request_method} -H "Authorization: Bearer {token}" "{url}/v2/{method}"

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator("https://{cpd_cluster_host}{:port}", "{username}", "{password}");
Assistant assistant = new Assistant("{version}", authenticator);
assistant.setServiceUrl("{url}";

HttpConfigOptions configOptions = new HttpConfigOptions.Builder()
  .disableSslVerification(true)
  .build();
assistant.configureClient(configOptions);

const AssistantV2 = require('ibm-watson/assistant/v2');
const { CloudPakForDataAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new CloudPakForDataAuthenticator({
    username: '{username}',
    password: '{password}',
    url: 'https://{cpd_cluster_host}{:port}',
  }),
  serviceUrl: '{url}',
  disableSslVerification: true,
});

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator

authenticator = CloudPakForDataAuthenticator(
    '{username}',
    '{password}'
)

assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('{url}')

assistant.set_disable_ssl_verification(True)

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::CLoudPakForDataAuthenticator.new(
  username: "{username}",
  password: "{password}",
  url: "https://{cpd_cluster_host}{:port}"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "{url}"

assistant.configure_http_client(disable_ssl_verification: true)

assistant, assistantErr := assistantv2.NewAssistantV2(options)

if assistantErr != nil {
  panic(assistantErr)
}

assistant.SetServiceURL("{url}")

assistant.DisableSSLVerification()

let authenticator = WatsonCloudPakForDataAuthenticator(username: "{username}", password: "{password}", url: "https://{cpd_cluster_host}{:port}")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "{url}"

assistant.disableSSLVerification()

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.DisableSslVerification(true);

var authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.DisableSslVerification = true;

curl --request POST   --url https://iam.platform.saas.ibm.com/siusermgr/api/1.0/apikeys/token   --header 'accept: application/json'   --header 'content-type: application/json'   --data {request-body}

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "{request-body}");
Request request = new Request.Builder()
  .url("https://iam.platform.saas.ibm.com/siusermgr/api/1.0/apikeys/token")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "application/json")
  .build();

Response response = client.newCall(request).execute();

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://iam.platform.saas.ibm.com/siusermgr/api/1.0/apikeys/token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = 'application/json'
request.body = "{request-body}"

response = http.request(request)
puts response.read_body

import http.client

conn = http.client.HTTPSConnection("iam.platform.saas.ibm.com")

payload = "{request-body}"

headers = {
    'content-type': "application/json",
    'accept': "application/json"
    }

conn.request("POST", "/siusermgr/api/1.0/apikeys/token", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

const request = require('request');

const options = {
  method: 'POST',
  url: 'https://iam.platform.saas.ibm.com/siusermgr/api/1.0/apikeys/token',
  headers: {'content-type': 'application/json', accept: 'application/json'},
  body: '{request-body}'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

curl -X POST "`{token_service_endpoint}`" -H "Content-Type: application/x-www-form-urlencoded" -d "grant_type=urn:ibm:params:oauth:grant_type:apikey&apikey={apikey}"

curl -X GET "{url}" -H "Authorization: Bearer {token}" -H "Content-Type: application/json"

Authenticator authenticator = new MCSPAuthenticator.Builder()
            .apikey("{apikey}")
            .url("{token_service_endpoint}")
            .build();
Assistant service = new Assistant("2023-06-15", authenticator);
service.setServiceUrl("{url}");

import AssistantV2 from 'ibm-watson/assistant/v2'
import { McspAuthenticator } from 'ibm-watson/auth';

# In the constructor, letting the SDK manage the token
const authenticator = new McspAuthenticator({
    url: '{token_service_endpoint}',
    apikey: '{apikey}',
})
const assistant = AssistantV2(version='2024-08-25',
                        authenticator=authenticator)
assistant.setServiceUrl('{url}')

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator

# In the constructor, letting the SDK manage the token
authenticator = MCSPAuthenticator('{apikey}', '{token_service_endpoint}')
assistant = AssistantV2(version='2023-06-15',
                        authenticator=authenticator)
assistant.set_service_url('{url}')

curl -X {request_method} -u "apikey:{apikey}" "{url}/v2/{method}"

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
Assistant assistant = new Assistant("{version}", authenticator);
assistant.setServiceUrl("{url}");

const AssistantV2 = require('ibm-watson/assistant/v2');
const { IamAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('{url}')

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "{url}"

import (
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/assistantv2"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey: "{apikey}",
  }

  options := &assistantv2.AssistantV2Options{
    Version: "{version}",
    Authenticator: authenticator,
  }

  assistant, assistantErr := assistantv2.NewAssistantV2(options)

  if assistantErr != nil {
    panic(assistantErr)
  }

  assistant.SetServiceURL("{url}")
}

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "{url}"

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

curl -k -X POST -H "cache-control: no-cache" -H "Content-Type: application/json" -d "{\"username\":\"{username}\",\"password\":\"{password}\"}" "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize"

curl -H "Authorization: Bearer {token}" "{url}/v2/{method}"

Authenticator authenticator = new BearerTokenAuthenticator("{access_token}");
Assistant service = new Assistant("{version}", authenticator);
service.setServiceUrl("{url}");

const AssistantV2 = require('ibm-watson/assistant/v2');
const { CloudPakForDataAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new CloudPakForDataAuthenticator({
    username: '{username}',
    password: '{password}',
    url: 'https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize',
  }),
  serviceUrl: '{url}',
});

from ibm_watson import AssistantV2
from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator

authenticator = CloudPakForDataAuthenticator(
    '{username}',
    '{password}',
    'https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize'
)

assistant = AssistantV2(
    version='{version}',
    authenticator=authenticator
)

assistant.set_service_url('{url}')

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v2"
include IBMWatson

authenticator = Authenticators::CloudPakForDataAuthenticator.new(
  username: "{username}",
  password: "{password}",
  url: "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize"
)
assistant = AssistantV2.new(
  version: "{version}",
  authenticator: authenticator
)
assistant.service_url = "{url}"

import (
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/assistantv2"
)

func main() {
  authenticator := &core.CloudPakForDataAuthenticator{
    URL: "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize",
    Username: "{username}",
    Password: "{password}",
  }

  options := &assistantv2.AssistantV2Options{
    Version: "{version}",
    Authenticator: authenticator,
  }

  assistant, assistantErr := assistantv2.NewAssistantV2(options)

  if assistantErr != nil {
    panic(assistantErr)
  }

  assistant.SetServiceURL("{url}")
}

let authenticator = WatsonCloudPakForDataAuthenticator(username: "{username}", password: "{password}", url: "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize")
let assistant = Assistant(version: "{version}", authenticator: authenticator)
assistant.serviceURL = "{url}"

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize",
    username: "{username}",
    password: "{password}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

var authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}/icp4d-api/v1/authorize",
    username: "{username}",
    password: "{password}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

try {
  // Invoke a method
} catch (NotFoundException e) {
  // Handle Not Found (404) exception
} catch (RequestTooLargeException e) {
  // Handle Request Too Large (413) exception
} catch (ServiceResponseException e) {
  // Base class for all exceptions caused by error responses from the service
  System.out.println("Service returned status code "
    + e.getStatusCode() + ": " + e.getMessage());
}

assistant.method(params)
  .catch(err => {
    console.log('error:', err);
  });

from ibm_watson import ApiException
try:
    # Invoke a method
except ApiException as ex:
    print "Method failed with status code " + str(ex.code) + ": " + ex.message

require "ibm_watson"
begin
  # Invoke a method
rescue IBMWatson::ApiException => ex
  print "Method failed with status code #{ex.code}: #{ex.error}"
end

import "github.com/watson-developer-cloud/go-sdk/assistantv2"

// Instantiate a service
assistant, assistantErr := assistantv2.NewAssistantV2(options)

// Check for errors
if assistantErr != nil {
  panic(assistantErr)
}

// Call a method
result, _, responseErr := assistant.MethodName(&methodOptions)

// Check for errors
if responseErr != nil {
  panic(responseErr)
}

assistant.method() {
  response, error in

  if let error = error {
    switch error {
    case let .http(statusCode, message, metadata):
      switch statusCode {
      case .some(404):
        // Handle Not Found (404) exception
        print("Not found")
      case .some(413):
        // Handle Request Too Large (413) exception
        print("Payload too large")
      default:
        if let statusCode = statusCode {
          print("Error - code: \(statusCode), \(message ?? "")")
        }
      }
    default:
      print(error.localizedDescription)
    }
    return
  }

  guard let result = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(result)
}

try
{
    // Invoke a method
}
catch(ServiceResponseException e)
{
    Console.WriteLine("Error: " + e.Message);
}
catch (Exception e)
{
    Console.WriteLine("Error: " + e.Message);
}

// Invoke a method
assistant.MethodName(Callback, Parameters);

// Check for errors
private void Callback(DetailedResponse<ExampleResponse> response, IBMError error)
{
    if (error == null)
    {
        Log.Debug("ExampleCallback", "Response received: {0}", response.Response);
    }
    else
    {
        Log.Debug("ExampleCallback", "Error received: {0}, {1}, {3}", error.StatusCode, error.ErrorMessage, error.Response);
    }
}

curl -X {request_method} -H "Request-Header: {header_value}" "{url}/v2/{method}"

ReturnType returnValue = assistant.methodName(parameters)
  .addHeader("Custom-Header", "{header_value}")
  .execute();

const parameters = {
  {parameters}
};

assistant.methodName(
  parameters,
  headers: {
    'Custom-Header': '{header_value}'
  })
   .then(result => {
    console.log(response);
  })
  .catch(err => {
    console.log('error:', err);
  });

response = assistant.methodName(
    parameters,
    headers = {
        'Custom-Header': '{header_value}'
    })

response = assistant.headers(
  "Custom-Header" => "{header_value}"
).methodName(parameters)

result, _, responseErr := assistant.MethodName(
  &methodOptions{
    Headers: map[string]string{
      "Accept": "application/json",
    },
  },
)

let customHeader: [String: String] = ["Custom-Header": "{header_value}"]
assistant.methodName(parameters, headers: customHeader) {
  response, error in
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.WithHeader("Custom-Header", "header_value");

CloudPakForDataAuthenticator authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://{cpd_cluster_host}{:port}/assistant/{release}/instances/{instance_id}/api");

assistant.WithHeader("Custom-Header", "header_value");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.WithHeader("Custom-Header", "header_value");

var authenticator = new CloudPakForDataAuthenticator(
    url: "https://{cpd_cluster_host}{:port}",
    username: "{username}",
    password: "{password}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("https://{cpd_cluster_host}{:port}/assistant/{release}/instances/{instance_id}/api");

assistant.WithHeader("Custom-Header", "header_value");

curl -X {request_method} {authentication_method} --include "{url}/v2/{method}"

Response<ReturnType> response = assistant.methodName(parameters)
  .executeWithDetails();
// Access response from methodName
ReturnType returnValue = response.getResult();
// Access information in response headers
Headers responseHeaders = response.getHeaders();

assistant.methodName(parameters)
  .then(response => {
    console.log(response.headers);
  })
  .catch(err => {
    console.log('error:', err);
  });

assistant.set_detailed_response(True)
response = assistant.methodName(parameters)
# Access response from methodName
print(json.dumps(response.get_result(), indent=2))
# Access information in response headers
print(response.get_headers())
# Access HTTP response status
print(response.get_status_code())

response = assistant.methodName(parameters)
# Access response from methodName
print response.result
# Access information in response headers
print response.headers
# Access HTTP response status
print response.status

import (
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/assistantv2"
)
result, response, responseErr := assistant.MethodName(
  &methodOptions{})
// Access result
core.PrettyPrint(response.GetResult(), "Result ")

// Access response headers
core.PrettyPrint(response.GetHeaders(), "Headers ")

// Access status code
core.PrettyPrint(response.GetStatusCode(), "Status Code ")

assistant.methodName(parameters) {
  response, error in

  guard let result = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }
  print(result) // The data returned by the service
  print(response?.statusCode)
  print(response?.headers)
}

var results = assistant.MethodName(parameters);

var result = results.Result;            //  The result object
var responseHeaders = results.Headers;  //  The response headers
var responseJson = results.Response;    //  The raw response JSON
var statusCode = results.StatusCode;    //  The response status code

private void Example()
{
    assistant.MethodName(Callback, Parameters);
}

private void Callback(DetailedResponse<ResponseType> response, IBMError error)
{
    var result = response.Result;                 //  The result object
    var responseHeaders = response.Headers;       //  The response headers
    var responseJson = reresponsesults.Response;  //  The raw response JSON
    var statusCode = response.StatusCode;         //  The response status code
}

curl -u "apikey:{apikey}" -H "X-Watson-Learning-Opt-Out: true" "{url}/{method}"

Map<String, String> headers = new HashMap<String, String>();
headers.put("X-Watson-Learning-Opt-Out", "true");

assistant.setDefaultHeaders(headers);

const AssistantV2 = require('ibm-watson/assistant/v2');
const { IamAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV2({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
  headers: {
    'X-Watson-Learning-Opt-Out': 'true'
  }
});

assistant.set_default_headers({'x-watson-learning-opt-out': "true"})

assistant.add_default_headers(headers: {"x-watson-learning-opt-out" => "true"})

import "net/http"

headers := http.Header{}
headers.Add("x-watson-learning-opt-out", "true")
assistant.SetDefaultHeaders(headers)

assistant.defaultHeaders["X-Watson-Learning-Opt-Out"] = "true"

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

AssistantService assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.WithHeader("X-Watson-Learning-Opt-Out", "true");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var assistant = new AssistantService("{version}", authenticator);
assistant.SetServiceUrl("{url}");

assistant.WithHeader("X-Watson-Learning-Opt-Out", "true");

ReturnType returnValue = assistant.method(parameters).execute();

assistant.method(parameters).enqueue(new ServiceCallback<ReturnType>() {
  @Override public void onResponse(ReturnType response) {
    . . .
  }
  @Override public void onFailure(Exception e) {
    . . .
  }
});

response = assistant.method_name(parameters)

response = assistant.await.method_name(parameters)

response = assistant.async.method_name(parameters)

curl -u "apikey:{apikey}" "{url}/v1/workspaces/{workspace_id}/intents/hello/examples?cursor=eyJ0ZXh0Ijp7Im9yZGVyIjoiYXNjIiwiaW5kZXgiOjAsInZhbHVlIjoiSGV5In0sInBfcyI6NH0=&version=2019-02-28"

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
Assistant assistant = new Assistant("2019-02-28", authenticator);
assistant.setServiceUrl("{url}");
String workspaceId = "{workspace_id}";
String intent = "hello";
String cursor = "";

do {
  ListExamplesOptions options = new ListExamplesOptions.Builder(workspaceId, intent)
    .pageLimit(3)
    .cursor(cursor)
    .build();
  ExampleCollection response = assistant.listExamples(options).execute().getResult();
  List<Example> examples = response.getExamples();
  cursor = response.getPagination().getNextCursor();
  for (Example example : examples) {
    System.out.println(example.text());
  }
}
while(cursor != null);

const AssistantV1 = require('ibm-watson/assistant/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const assistant = new AssistantV1({
  version: '2019-02-28',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});
const cursor = null;

getNextPage(cursor);

function getNextPage(cursor) {
  const params = {
    workspaceId: '{workspace_id}',
    intent: 'hello',
    cursor,
    pageLimit: 3,
  };
  assistant.listExamples(params)
    .then(res => {
      for (const example in res.result.examples) {
        console.log(res.result.examples[example]['text']);
      }
      if(res.result.pagination.next_cursor) {
        getNextPage(res.result.pagination.next_cursor)
      }
    })
    .catch(err => {
      console.log(err)
    });
}

from ibm_watson import AssistantV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
assistant = AssistantV1(
    version='2019-02-28',
    authenticator = authenticator
)
assistant.set_service_url('{url}')
cursor = None

while True:
    response=assistant.list_examples(
        workspace_id='{workspace_id}',
        intent='hello',
        cursor=cursor,
        page_limit=3
    ).get_result()

    for example in response.get('examples'):
        print(example.get('text'))

    cursor=response.get('pagination').get('next_cursor')
    if not cursor:
        break

require "ibm_watson/authenticators"
require "ibm_watson/assistant_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
assistant = AssistantV1.new(
  version: "2019-02-28",
  authenticator: authenticator
)
assistant.service_url = "{url}"
cursor = nil

loop do
  response = assistant.list_examples(
    workspace_id: "{workspace_id}",
    intent: "hello",
    page_limit: 3,
    cursor: cursor
  )
  response.result["examples"].each { |example|
    puts example["text"]
  }
  cursor = response.result["pagination"]["next_cursor"]
  if cursor.nil?
    break
  end
end

package main

import (
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/assistantv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey: "{apikey}",
  }
  options := &assistantv1.AssistantV1Options{
    Version: "2019-02-28",
    Authenticator: authenticator,
  }
  assistant, assistantErr := assistantv1.NewAssistantV1(options)
  if assistantErr != nil {
    panic(assistantErr)
  }

  assistant.SetServiceURL("{url}")
  cursor := core.StringPtr("")
  pageLimit := int64(3)

  for {
    result, _, responseErr := assistant.ListExamples(
      &assistantv1.ListExamplesOptions{
        WorkspaceID: core.StringPtr("{workspace_id}"),
        Intent: core.StringPtr("hello"),
        PageLimit: &pageLimit,
        Cursor: cursor,
     },
    )
    if responseErr != nil {
      panic(responseErr)
    }
    for _, example := range result.Examples {
      fmt.Println(*example.Text)
    }
    cursor = result.Pagination.NextCursor
    if cursor == nil {
      break
    }
  }
}

import Foundation
import AssistantV1
let authenticator = WatsonIAMAuthenticator.init(apiKey: "{apikey}")
assistant = Assistant(version: "2019-02-28", authenticator: authenticator)
assistant.serviceURL = "{url}"
func getNextPage(cursor: String?) {
    assistant.listExamples(workspaceID: "{workspace_id}", intent: "hello", pageLimit: 2, cursor: cursor) {
        response, error in
        if let error = error {
            print(error.localizedDescription)
            return
        }
        guard let results = response?.result else {
            print("No results found")
            return
        }
        for example in results.examples {
            print(example)
        }
        if let cursor = examples.pagination.nextCursor {
            getNextPage(cursor?)
        }
    }
}
getNextPage(cursor: nil)

public class ListExamplesWithPagination
{
    public ListExamplesWithPagination()
    {
        IamAuthenticator authenticator = new IamAuthenticator(apikey: "{apikey}");
        AssistantService service = new AssistantService("2019-02-28", authenticator);
        service.SetServiceUrl("{url}");
        string workspaceId = "{workspace_id}";
        string intent = "hello";
        long? pageLimit = 3;
        string cursor = "";
        ListExamples(service, workspaceId, intent, pageLimit, cursor);
    }
    public void ListExamples(AssistantService service, string workspaceId, string intent, long? pageLimit, string cursor)
    {
        var result = service.ListExamples(
            workspaceId: workspaceId,
            intent: intent,
            pageLimit: 3,
            cursor: cursor
        );
        foreach (Example example in result.Result.Examples)
        {
            Console.WriteLine(example.Text);
        }
        var nextCursor = result.Result.Pagination.NextCursor;
        if (!string.IsNullOrEmpty(nextCursor))
        {
            ListExamples(service, workspaceId, intent, pageLimit, nextCursor);
        }
    }
}

public void ListExamples(AssistantService service, string workspaceId, string intent, long? pageLimit, string cursor)
{
    ExampleCollection listExamplesResponse = null;
    service.ListExamples(
        callback: (DetailedResponse<ExampleCollection> response, IBMError error) =>
        {
            Log.Debug("AssistantServiceV1", "ListExamples result: {0}", response.Response);
            listExamplesResponse = response.Result;
            foreach (Example example in listExamplesResponse.Examples)
            {
                Log.Debug("AssistantServiceV1", "Example text: {0}", example.Text);
            }
            var nextCursor = listExamplesResponse.Pagination.NextCursor;
            if (!string.IsNullOrEmpty(nextCursor))
            {
                ListExamples(service, workspaceId, intent, pageLimit, nextCursor);
            }
            else
            {
                paginationDone = true;
            }
        },
        workspaceId: workspaceId,
        intent: intent,
        pageLimit: 3,
        cursor: cursor
    );
}
var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);
while (!authenticator.CanAuthenticate())
    yield return null;
var assistant = new AssistantService("2019-02-28", authenticator);
assistant.SetServiceUrl("{url}");
bool isPaginationDone = false;
string workspaceId = "{workspace_id}";
string intent = "hello";
long? pageLimit = 3;
string cursor = "";
ListExamples(service, workspaceId, intent, pageLimit, cursor);
while (isPaginationDone == false)
    yield return null;