")
+ .input(input)
+ .build();
+MessageResponse messageResponse = service.message(messageOptions).execute().getResult();
+
+System.out.println(messageResponse);
+```
+
+Maintaining context across messages:
+
+```java
+// make sure to use the Assistant v2 import!
+import com.ibm.watson.assistant.v2.Assistant;
+
+MessageContext context = new MessageContext();
+
+// first message
+MessageInput input = new MessageInput.Builder()
+ .text("First message")
+ .build();
+MessageOptions messageOptions = new MessageOptions.Builder()
+ .assistantId(assistantId)
+ .sessionId(sessionId)
+ .input(input)
+ .context(context)
+ .build();
+
+MessageResponse messageResponse = service.message(messageOptions).execute().getResult();
+context = messageResponse.getContext();
+
+// second message
+input = new MessageInput.Builder()
+ .text("Second message")
+ .build();
+messageOptions = new MessageOptions.Builder()
+ .assistantId(assistantId)
+ .sessionId(sessionId)
+ .input(input)
+ .context(context) // using context from first message
+ .build();
+
+messageResponse = service.message(messageOptions).execute().getResult();
+
+System.out.println(messageResponse);
+```
+
+[assistant]: https://cloud.ibm.com/docs/assistant?topic=assistant-index
diff --git a/assistant/build.gradle b/assistant/build.gradle
deleted file mode 100644
index 7d4d76d802c..00000000000
--- a/assistant/build.gradle
+++ /dev/null
@@ -1,112 +0,0 @@
-plugins {
- id 'ru.vyarus.animalsniffer' version '1.3.0'
-}
-
-defaultTasks 'clean'
-
-apply from: '../utils.gradle'
-import org.apache.tools.ant.filters.*
-
-apply plugin: 'java'
-apply plugin: 'ru.vyarus.animalsniffer'
-apply plugin: 'maven'
-apply plugin: 'signing'
-apply plugin: 'checkstyle'
-apply plugin: 'eclipse'
-
-task javadocJar(type: Jar) {
- classifier = 'javadoc'
- from javadoc
-}
-
-task sourcesJar(type: Jar) {
- classifier = 'sources'
- from sourceSets.main.allSource
-}
-
-repositories {
- mavenCentral()
-}
-
-artifacts {
- archives sourcesJar
- archives javadocJar
-}
-
-signing {
- sign configurations.archives
-}
-
-signArchives {
- onlyIf { Task task ->
- def shouldExec = false
- for (myArg in project.gradle.startParameter.taskRequests[0].args) {
- if (myArg.toLowerCase().contains('signjars') || myArg.toLowerCase().contains('uploadarchives')) {
- shouldExec = true
- }
- }
- return shouldExec
- }
-}
-
-checkstyle {
- configFile = rootProject.file('checkstyle.xml')
- ignoreFailures = false
-}
-
-dependencies {
- compile project(':core')
-
- testCompile project(path: ':core', configuration: 'tests')
- signature 'org.codehaus.mojo.signature:java17:1.0@signature'
-}
-
-processResources {
- filter ReplaceTokens, tokens: [
- "pom.version": project.version,
- "build.date" : getDate()
- ]
-}
-
-uploadArchives {
- repositories {
- mavenDeployer {
- beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
-
- repository(url: "http://oss.sonatype.org/service/local/staging/deploy/maven2/") {
- authentication(userName: System.env.CI_DEPLOY_USERNAME, password: System.env.CI_DEPLOY_PASSWORD)
- }
- snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/"){
- authentication(userName: System.env.CI_DEPLOY_USERNAME, password: System.env.CI_DEPLOY_PASSWORD)
- }
- pom.project {
- name 'conversation'
- packaging 'jar'
- // optionally artifactId can be defined here
- description 'Client library to use the IBM Watson Assistant Service'
- url 'https://console.bluemix.net/docs/services/assistant/index.html'
-
- scm {
- connection 'scm:git:git@github.com:watson-developer-cloud/java-sdk.git'
- developerConnection 'scm:git:git@github.com:watson-developer-cloud/java-sdk.git'
- url 'https://github.com/watson-developer-cloud/java-sdk'
- }
-
- licenses {
- license {
- name 'The Apache License, Version 2.0'
- url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
- }
- }
-
- developers {
- developer {
- id 'german'
- name 'German Attanasio'
- email 'germanatt@us.ibm.com'
- }
- }
- }
- }
- }
-}
diff --git a/assistant/pom.xml b/assistant/pom.xml
new file mode 100644
index 00000000000..5450d344495
--- /dev/null
+++ b/assistant/pom.xml
@@ -0,0 +1,67 @@
+
+ 4.0.0
+
+
+ ibm-watson-parent
+ com.ibm.watson
+ 99-SNAPSHOT
+ ../pom.xml
+
+
+ assistant
+ jar
+ IBM Watson Java SDK - Assistant
+
+
+
+ com.ibm.cloud
+ sdk-core
+
+
+ ${project.groupId}
+ common
+ compile
+
+
+ ${project.groupId}
+ common
+ test-jar
+ tests
+ test
+
+
+ org.testng
+ testng
+ test
+
+
+ com.launchdarkly
+ okhttp-eventsource
+ 4.1.1
+
+
+ com.squareup.okhttp3
+ mockwebserver
+ test
+
+
+ org.powermock
+ powermock-api-mockito2
+ test
+
+
+ org.powermock
+ powermock-module-testng
+ test
+
+
+
+
+ Watson Developer Experience
+ watdevex@us.ibm.com
+ https://www.ibm.com/
+
+
+
diff --git a/assistant/src/main/java/com/ibm/watson/assistant/v1/Assistant.java b/assistant/src/main/java/com/ibm/watson/assistant/v1/Assistant.java
new file mode 100644
index 00000000000..2c99bedb32f
--- /dev/null
+++ b/assistant/src/main/java/com/ibm/watson/assistant/v1/Assistant.java
@@ -0,0 +1,2765 @@
+/*
+ * (C) Copyright IBM Corp. 2019, 2024.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+/*
+ * IBM OpenAPI SDK Code Generator Version: 3.97.0-0e90eab1-20241120-170029
+ */
+
+package com.ibm.watson.assistant.v1;
+
+import com.google.gson.JsonObject;
+import com.ibm.cloud.sdk.core.http.RequestBuilder;
+import com.ibm.cloud.sdk.core.http.ResponseConverter;
+import com.ibm.cloud.sdk.core.http.ServiceCall;
+import com.ibm.cloud.sdk.core.security.Authenticator;
+import com.ibm.cloud.sdk.core.security.ConfigBasedAuthenticatorFactory;
+import com.ibm.cloud.sdk.core.service.BaseService;
+import com.ibm.cloud.sdk.core.util.ResponseConverterUtils;
+import com.ibm.watson.assistant.v1.model.BulkClassifyOptions;
+import com.ibm.watson.assistant.v1.model.BulkClassifyResponse;
+import com.ibm.watson.assistant.v1.model.Counterexample;
+import com.ibm.watson.assistant.v1.model.CounterexampleCollection;
+import com.ibm.watson.assistant.v1.model.CreateCounterexampleOptions;
+import com.ibm.watson.assistant.v1.model.CreateDialogNodeOptions;
+import com.ibm.watson.assistant.v1.model.CreateEntityOptions;
+import com.ibm.watson.assistant.v1.model.CreateExampleOptions;
+import com.ibm.watson.assistant.v1.model.CreateIntentOptions;
+import com.ibm.watson.assistant.v1.model.CreateSynonymOptions;
+import com.ibm.watson.assistant.v1.model.CreateValueOptions;
+import com.ibm.watson.assistant.v1.model.CreateWorkspaceAsyncOptions;
+import com.ibm.watson.assistant.v1.model.CreateWorkspaceOptions;
+import com.ibm.watson.assistant.v1.model.DeleteCounterexampleOptions;
+import com.ibm.watson.assistant.v1.model.DeleteDialogNodeOptions;
+import com.ibm.watson.assistant.v1.model.DeleteEntityOptions;
+import com.ibm.watson.assistant.v1.model.DeleteExampleOptions;
+import com.ibm.watson.assistant.v1.model.DeleteIntentOptions;
+import com.ibm.watson.assistant.v1.model.DeleteSynonymOptions;
+import com.ibm.watson.assistant.v1.model.DeleteUserDataOptions;
+import com.ibm.watson.assistant.v1.model.DeleteValueOptions;
+import com.ibm.watson.assistant.v1.model.DeleteWorkspaceOptions;
+import com.ibm.watson.assistant.v1.model.DialogNode;
+import com.ibm.watson.assistant.v1.model.DialogNodeCollection;
+import com.ibm.watson.assistant.v1.model.Entity;
+import com.ibm.watson.assistant.v1.model.EntityCollection;
+import com.ibm.watson.assistant.v1.model.EntityMentionCollection;
+import com.ibm.watson.assistant.v1.model.Example;
+import com.ibm.watson.assistant.v1.model.ExampleCollection;
+import com.ibm.watson.assistant.v1.model.ExportWorkspaceAsyncOptions;
+import com.ibm.watson.assistant.v1.model.GetCounterexampleOptions;
+import com.ibm.watson.assistant.v1.model.GetDialogNodeOptions;
+import com.ibm.watson.assistant.v1.model.GetEntityOptions;
+import com.ibm.watson.assistant.v1.model.GetExampleOptions;
+import com.ibm.watson.assistant.v1.model.GetIntentOptions;
+import com.ibm.watson.assistant.v1.model.GetSynonymOptions;
+import com.ibm.watson.assistant.v1.model.GetValueOptions;
+import com.ibm.watson.assistant.v1.model.GetWorkspaceOptions;
+import com.ibm.watson.assistant.v1.model.Intent;
+import com.ibm.watson.assistant.v1.model.IntentCollection;
+import com.ibm.watson.assistant.v1.model.ListAllLogsOptions;
+import com.ibm.watson.assistant.v1.model.ListCounterexamplesOptions;
+import com.ibm.watson.assistant.v1.model.ListDialogNodesOptions;
+import com.ibm.watson.assistant.v1.model.ListEntitiesOptions;
+import com.ibm.watson.assistant.v1.model.ListExamplesOptions;
+import com.ibm.watson.assistant.v1.model.ListIntentsOptions;
+import com.ibm.watson.assistant.v1.model.ListLogsOptions;
+import com.ibm.watson.assistant.v1.model.ListMentionsOptions;
+import com.ibm.watson.assistant.v1.model.ListSynonymsOptions;
+import com.ibm.watson.assistant.v1.model.ListValuesOptions;
+import com.ibm.watson.assistant.v1.model.ListWorkspacesOptions;
+import com.ibm.watson.assistant.v1.model.LogCollection;
+import com.ibm.watson.assistant.v1.model.MessageOptions;
+import com.ibm.watson.assistant.v1.model.MessageResponse;
+import com.ibm.watson.assistant.v1.model.Synonym;
+import com.ibm.watson.assistant.v1.model.SynonymCollection;
+import com.ibm.watson.assistant.v1.model.UpdateCounterexampleOptions;
+import com.ibm.watson.assistant.v1.model.UpdateDialogNodeNullableOptions;
+import com.ibm.watson.assistant.v1.model.UpdateDialogNodeOptions;
+import com.ibm.watson.assistant.v1.model.UpdateEntityOptions;
+import com.ibm.watson.assistant.v1.model.UpdateExampleOptions;
+import com.ibm.watson.assistant.v1.model.UpdateIntentOptions;
+import com.ibm.watson.assistant.v1.model.UpdateSynonymOptions;
+import com.ibm.watson.assistant.v1.model.UpdateValueOptions;
+import com.ibm.watson.assistant.v1.model.UpdateWorkspaceAsyncOptions;
+import com.ibm.watson.assistant.v1.model.UpdateWorkspaceOptions;
+import com.ibm.watson.assistant.v1.model.Value;
+import com.ibm.watson.assistant.v1.model.ValueCollection;
+import com.ibm.watson.assistant.v1.model.Workspace;
+import com.ibm.watson.assistant.v1.model.WorkspaceCollection;
+import com.ibm.watson.common.SdkCommon;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * The IBM Watson™ Assistant service combines machine learning, natural language
+ * understanding, and an integrated dialog editor to create conversation flows between your apps and
+ * your users.
+ *
+ * The Assistant v1 API provides authoring methods your application can use to create or update a
+ * workspace.
+ *
+ *
API Version: 1.0 See: https://cloud.ibm.com/docs/assistant
+ */
+public class Assistant extends BaseService {
+
+ /** Default service name used when configuring the `Assistant` client. */
+ public static final String DEFAULT_SERVICE_NAME = "assistant";
+
+ /** Default service endpoint URL. */
+ public static final String DEFAULT_SERVICE_URL =
+ "https://api.us-south.assistant.watson.cloud.ibm.com";
+
+ private String version;
+
+ /**
+ * Constructs an instance of the `Assistant` client. The default service name is used to configure
+ * the client instance.
+ *
+ * @param version Release date of the API version you want to use. Specify dates in YYYY-MM-DD
+ * format. The current version is `2021-11-27`.
+ */
+ public Assistant(String version) {
+ this(
+ version,
+ DEFAULT_SERVICE_NAME,
+ ConfigBasedAuthenticatorFactory.getAuthenticator(DEFAULT_SERVICE_NAME));
+ }
+
+ /**
+ * Constructs an instance of the `Assistant` client. The default service name and specified
+ * authenticator are used to configure the client instance.
+ *
+ * @param version Release date of the API version you want to use. Specify dates in YYYY-MM-DD
+ * format. The current version is `2021-11-27`.
+ * @param authenticator the {@link Authenticator} instance to be configured for this client
+ */
+ public Assistant(String version, Authenticator authenticator) {
+ this(version, DEFAULT_SERVICE_NAME, authenticator);
+ }
+
+ /**
+ * Constructs an instance of the `Assistant` client. The specified service name is used to
+ * configure the client instance.
+ *
+ * @param version Release date of the API version you want to use. Specify dates in YYYY-MM-DD
+ * format. The current version is `2021-11-27`.
+ * @param serviceName the service name to be used when configuring the client instance
+ */
+ public Assistant(String version, String serviceName) {
+ this(version, serviceName, ConfigBasedAuthenticatorFactory.getAuthenticator(serviceName));
+ }
+
+ /**
+ * Constructs an instance of the `Assistant` client. The specified service name and authenticator
+ * are used to configure the client instance.
+ *
+ * @param version Release date of the API version you want to use. Specify dates in YYYY-MM-DD
+ * format. The current version is `2021-11-27`.
+ * @param serviceName the service name to be used when configuring the client instance
+ * @param authenticator the {@link Authenticator} instance to be configured for this client
+ */
+ public Assistant(String version, String serviceName, Authenticator authenticator) {
+ super(serviceName, authenticator);
+ setServiceUrl(DEFAULT_SERVICE_URL);
+ setVersion(version);
+ this.configureService(serviceName);
+ }
+
+ /**
+ * Gets the version.
+ *
+ *
Release date of the API version you want to use. Specify dates in YYYY-MM-DD format. The
+ * current version is `2021-11-27`.
+ *
+ * @return the version
+ */
+ public String getVersion() {
+ return this.version;
+ }
+
+ /**
+ * Sets the version.
+ *
+ * @param version the new version
+ */
+ public void setVersion(final String version) {
+ com.ibm.cloud.sdk.core.util.Validator.notEmpty(version, "version cannot be empty.");
+ this.version = version;
+ }
+
+ /**
+ * Update dialog node.
+ *
+ *
Update an existing dialog node with new or modified data.
+ *
+ *
If you want to update multiple dialog nodes with a single API call, consider using the
+ * **[Update workspace](#update-workspace)** method instead.
+ *
+ * @param UpdateDialogNodeNullableOptions the {@link UpdateDialogNodeNullableOptions} containing
+ * the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link DialogNode}
+ */
+ public ServiceCall updateDialogNodeNullable(
+ UpdateDialogNodeNullableOptions UpdateDialogNodeNullableOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ UpdateDialogNodeNullableOptions, "UpdateDialogNodeNullableOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", UpdateDialogNodeNullableOptions.workspaceId());
+ pathParamsMap.put("dialog_node", UpdateDialogNodeNullableOptions.dialogNode());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/dialog_nodes/{dialog_node}",
+ pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "testUpdateDialogNode");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (UpdateDialogNodeNullableOptions.includeAudit() != null) {
+ builder.query(
+ "include_audit", String.valueOf(UpdateDialogNodeNullableOptions.includeAudit()));
+ }
+ builder.bodyContent(
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGsonWithSerializeNulls()
+ .toJson(UpdateDialogNodeNullableOptions.body()),
+ "application/json");
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Get response to user input.
+ *
+ * Send user input to a workspace and receive a response.
+ *
+ *
**Important:** This method has been superseded by the new v2 runtime API. The v2 API offers
+ * significant advantages, including ease of deployment, automatic state management, versioning,
+ * and search capabilities. For more information, see the
+ * [documentation](https://cloud.ibm.com/docs/assistant?topic=assistant-api-overview).
+ *
+ * @param messageOptions the {@link MessageOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link MessageResponse}
+ */
+ public ServiceCall message(MessageOptions messageOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(messageOptions, "messageOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", messageOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/message", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "message");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (messageOptions.nodesVisitedDetails() != null) {
+ builder.query("nodes_visited_details", String.valueOf(messageOptions.nodesVisitedDetails()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ if (messageOptions.input() != null) {
+ contentJson.add(
+ "input",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson().toJsonTree(messageOptions.input()));
+ }
+ if (messageOptions.intents() != null) {
+ contentJson.add(
+ "intents",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson().toJsonTree(messageOptions.intents()));
+ }
+ if (messageOptions.entities() != null) {
+ contentJson.add(
+ "entities",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(messageOptions.entities()));
+ }
+ if (messageOptions.alternateIntents() != null) {
+ contentJson.addProperty("alternate_intents", messageOptions.alternateIntents());
+ }
+ if (messageOptions.context() != null) {
+ contentJson.add(
+ "context",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson().toJsonTree(messageOptions.context()));
+ }
+ if (messageOptions.output() != null) {
+ contentJson.add(
+ "output",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson().toJsonTree(messageOptions.output()));
+ }
+ if (messageOptions.userId() != null) {
+ contentJson.addProperty("user_id", messageOptions.userId());
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Identify intents and entities in multiple user utterances.
+ *
+ * Send multiple user inputs to a workspace in a single request and receive information about
+ * the intents and entities recognized in each input. This method is useful for testing and
+ * comparing the performance of different workspaces.
+ *
+ *
This method is available only with Enterprise with Data Isolation plans.
+ *
+ * @param bulkClassifyOptions the {@link BulkClassifyOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link BulkClassifyResponse}
+ */
+ public ServiceCall bulkClassify(BulkClassifyOptions bulkClassifyOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ bulkClassifyOptions, "bulkClassifyOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", bulkClassifyOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/bulk_classify", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "bulkClassify");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ final JsonObject contentJson = new JsonObject();
+ if (bulkClassifyOptions.input() != null) {
+ contentJson.add(
+ "input",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(bulkClassifyOptions.input()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * List workspaces.
+ *
+ * List the workspaces associated with a Watson Assistant service instance.
+ *
+ * @param listWorkspacesOptions the {@link ListWorkspacesOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a result of type {@link WorkspaceCollection}
+ */
+ public ServiceCall listWorkspaces(
+ ListWorkspacesOptions listWorkspacesOptions) {
+ if (listWorkspacesOptions == null) {
+ listWorkspacesOptions = new ListWorkspacesOptions.Builder().build();
+ }
+ RequestBuilder builder =
+ RequestBuilder.get(RequestBuilder.resolveRequestUrl(getServiceUrl(), "/v1/workspaces"));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "listWorkspaces");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (listWorkspacesOptions.pageLimit() != null) {
+ builder.query("page_limit", String.valueOf(listWorkspacesOptions.pageLimit()));
+ }
+ if (listWorkspacesOptions.includeCount() != null) {
+ builder.query("include_count", String.valueOf(listWorkspacesOptions.includeCount()));
+ }
+ if (listWorkspacesOptions.sort() != null) {
+ builder.query("sort", String.valueOf(listWorkspacesOptions.sort()));
+ }
+ if (listWorkspacesOptions.cursor() != null) {
+ builder.query("cursor", String.valueOf(listWorkspacesOptions.cursor()));
+ }
+ if (listWorkspacesOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(listWorkspacesOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * List workspaces.
+ *
+ * List the workspaces associated with a Watson Assistant service instance.
+ *
+ * @return a {@link ServiceCall} with a result of type {@link WorkspaceCollection}
+ */
+ public ServiceCall listWorkspaces() {
+ return listWorkspaces(null);
+ }
+
+ /**
+ * Create workspace.
+ *
+ * Create a workspace based on component objects. You must provide workspace components
+ * defining the content of the new workspace.
+ *
+ *
**Note:** The new workspace data cannot be larger than 1.5 MB. For larger requests, use the
+ * **Create workspace asynchronously** method.
+ *
+ * @param createWorkspaceOptions the {@link CreateWorkspaceOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall createWorkspace(CreateWorkspaceOptions createWorkspaceOptions) {
+ boolean skipBody = false;
+ if (createWorkspaceOptions == null) {
+ createWorkspaceOptions = new CreateWorkspaceOptions.Builder().build();
+ skipBody = true;
+ }
+ RequestBuilder builder =
+ RequestBuilder.post(RequestBuilder.resolveRequestUrl(getServiceUrl(), "/v1/workspaces"));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "createWorkspace");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (createWorkspaceOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(createWorkspaceOptions.includeAudit()));
+ }
+ if (!skipBody) {
+ final JsonObject contentJson = new JsonObject();
+ if (createWorkspaceOptions.name() != null) {
+ contentJson.addProperty("name", createWorkspaceOptions.name());
+ }
+ if (createWorkspaceOptions.description() != null) {
+ contentJson.addProperty("description", createWorkspaceOptions.description());
+ }
+ if (createWorkspaceOptions.language() != null) {
+ contentJson.addProperty("language", createWorkspaceOptions.language());
+ }
+ if (createWorkspaceOptions.dialogNodes() != null) {
+ contentJson.add(
+ "dialog_nodes",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.dialogNodes()));
+ }
+ if (createWorkspaceOptions.counterexamples() != null) {
+ contentJson.add(
+ "counterexamples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.counterexamples()));
+ }
+ if (createWorkspaceOptions.metadata() != null) {
+ contentJson.add(
+ "metadata",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.metadata()));
+ }
+ if (createWorkspaceOptions.learningOptOut() != null) {
+ contentJson.addProperty("learning_opt_out", createWorkspaceOptions.learningOptOut());
+ }
+ if (createWorkspaceOptions.systemSettings() != null) {
+ contentJson.add(
+ "system_settings",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.systemSettings()));
+ }
+ if (createWorkspaceOptions.webhooks() != null) {
+ contentJson.add(
+ "webhooks",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.webhooks()));
+ }
+ if (createWorkspaceOptions.intents() != null) {
+ contentJson.add(
+ "intents",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.intents()));
+ }
+ if (createWorkspaceOptions.entities() != null) {
+ contentJson.add(
+ "entities",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceOptions.entities()));
+ }
+ builder.bodyJson(contentJson);
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create workspace.
+ *
+ * Create a workspace based on component objects. You must provide workspace components
+ * defining the content of the new workspace.
+ *
+ *
**Note:** The new workspace data cannot be larger than 1.5 MB. For larger requests, use the
+ * **Create workspace asynchronously** method.
+ *
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall createWorkspace() {
+ return createWorkspace(null);
+ }
+
+ /**
+ * Get information about a workspace.
+ *
+ * Get information about a workspace, optionally including all workspace content.
+ *
+ * @param getWorkspaceOptions the {@link GetWorkspaceOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall getWorkspace(GetWorkspaceOptions getWorkspaceOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ getWorkspaceOptions, "getWorkspaceOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", getWorkspaceOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "getWorkspace");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (getWorkspaceOptions.export() != null) {
+ builder.query("export", String.valueOf(getWorkspaceOptions.export()));
+ }
+ if (getWorkspaceOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(getWorkspaceOptions.includeAudit()));
+ }
+ if (getWorkspaceOptions.sort() != null) {
+ builder.query("sort", String.valueOf(getWorkspaceOptions.sort()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Update workspace.
+ *
+ * Update an existing workspace with new or modified data. You must provide component objects
+ * defining the content of the updated workspace.
+ *
+ *
**Note:** The new workspace data cannot be larger than 1.5 MB. For larger requests, use the
+ * **Update workspace asynchronously** method.
+ *
+ * @param updateWorkspaceOptions the {@link UpdateWorkspaceOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall updateWorkspace(UpdateWorkspaceOptions updateWorkspaceOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ updateWorkspaceOptions, "updateWorkspaceOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", updateWorkspaceOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}", pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "updateWorkspace");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (updateWorkspaceOptions.append() != null) {
+ builder.query("append", String.valueOf(updateWorkspaceOptions.append()));
+ }
+ if (updateWorkspaceOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(updateWorkspaceOptions.includeAudit()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ if (updateWorkspaceOptions.name() != null) {
+ contentJson.addProperty("name", updateWorkspaceOptions.name());
+ }
+ if (updateWorkspaceOptions.description() != null) {
+ contentJson.addProperty("description", updateWorkspaceOptions.description());
+ }
+ if (updateWorkspaceOptions.language() != null) {
+ contentJson.addProperty("language", updateWorkspaceOptions.language());
+ }
+ if (updateWorkspaceOptions.dialogNodes() != null) {
+ contentJson.add(
+ "dialog_nodes",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.dialogNodes()));
+ }
+ if (updateWorkspaceOptions.counterexamples() != null) {
+ contentJson.add(
+ "counterexamples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.counterexamples()));
+ }
+ if (updateWorkspaceOptions.metadata() != null) {
+ contentJson.add(
+ "metadata",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.metadata()));
+ }
+ if (updateWorkspaceOptions.learningOptOut() != null) {
+ contentJson.addProperty("learning_opt_out", updateWorkspaceOptions.learningOptOut());
+ }
+ if (updateWorkspaceOptions.systemSettings() != null) {
+ contentJson.add(
+ "system_settings",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.systemSettings()));
+ }
+ if (updateWorkspaceOptions.webhooks() != null) {
+ contentJson.add(
+ "webhooks",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.webhooks()));
+ }
+ if (updateWorkspaceOptions.intents() != null) {
+ contentJson.add(
+ "intents",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.intents()));
+ }
+ if (updateWorkspaceOptions.entities() != null) {
+ contentJson.add(
+ "entities",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceOptions.entities()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Delete workspace.
+ *
+ * Delete a workspace from the service instance.
+ *
+ * @param deleteWorkspaceOptions the {@link DeleteWorkspaceOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a void result
+ */
+ public ServiceCall deleteWorkspace(DeleteWorkspaceOptions deleteWorkspaceOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ deleteWorkspaceOptions, "deleteWorkspaceOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", deleteWorkspaceOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.delete(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}", pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "deleteWorkspace");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ ResponseConverter responseConverter = ResponseConverterUtils.getVoid();
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create workspace asynchronously.
+ *
+ * Create a workspace asynchronously based on component objects. You must provide workspace
+ * components defining the content of the new workspace.
+ *
+ *
A successful call to this method only initiates asynchronous creation of the workspace. The
+ * new workspace is not available until processing completes. To check the status of the
+ * asynchronous operation, use the **Get information about a workspace** method.
+ *
+ * @param createWorkspaceAsyncOptions the {@link CreateWorkspaceAsyncOptions} containing the
+ * options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall createWorkspaceAsync(
+ CreateWorkspaceAsyncOptions createWorkspaceAsyncOptions) {
+ boolean skipBody = false;
+ if (createWorkspaceAsyncOptions == null) {
+ createWorkspaceAsyncOptions = new CreateWorkspaceAsyncOptions.Builder().build();
+ skipBody = true;
+ }
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(getServiceUrl(), "/v1/workspaces_async"));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "createWorkspaceAsync");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (!skipBody) {
+ final JsonObject contentJson = new JsonObject();
+ if (createWorkspaceAsyncOptions.name() != null) {
+ contentJson.addProperty("name", createWorkspaceAsyncOptions.name());
+ }
+ if (createWorkspaceAsyncOptions.description() != null) {
+ contentJson.addProperty("description", createWorkspaceAsyncOptions.description());
+ }
+ if (createWorkspaceAsyncOptions.language() != null) {
+ contentJson.addProperty("language", createWorkspaceAsyncOptions.language());
+ }
+ if (createWorkspaceAsyncOptions.dialogNodes() != null) {
+ contentJson.add(
+ "dialog_nodes",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.dialogNodes()));
+ }
+ if (createWorkspaceAsyncOptions.counterexamples() != null) {
+ contentJson.add(
+ "counterexamples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.counterexamples()));
+ }
+ if (createWorkspaceAsyncOptions.metadata() != null) {
+ contentJson.add(
+ "metadata",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.metadata()));
+ }
+ if (createWorkspaceAsyncOptions.learningOptOut() != null) {
+ contentJson.addProperty("learning_opt_out", createWorkspaceAsyncOptions.learningOptOut());
+ }
+ if (createWorkspaceAsyncOptions.systemSettings() != null) {
+ contentJson.add(
+ "system_settings",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.systemSettings()));
+ }
+ if (createWorkspaceAsyncOptions.webhooks() != null) {
+ contentJson.add(
+ "webhooks",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.webhooks()));
+ }
+ if (createWorkspaceAsyncOptions.intents() != null) {
+ contentJson.add(
+ "intents",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.intents()));
+ }
+ if (createWorkspaceAsyncOptions.entities() != null) {
+ contentJson.add(
+ "entities",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createWorkspaceAsyncOptions.entities()));
+ }
+ builder.bodyJson(contentJson);
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create workspace asynchronously.
+ *
+ * Create a workspace asynchronously based on component objects. You must provide workspace
+ * components defining the content of the new workspace.
+ *
+ *
A successful call to this method only initiates asynchronous creation of the workspace. The
+ * new workspace is not available until processing completes. To check the status of the
+ * asynchronous operation, use the **Get information about a workspace** method.
+ *
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall createWorkspaceAsync() {
+ return createWorkspaceAsync(null);
+ }
+
+ /**
+ * Update workspace asynchronously.
+ *
+ * Update an existing workspace asynchronously with new or modified data. You must provide
+ * component objects defining the content of the updated workspace.
+ *
+ *
A successful call to this method only initiates an asynchronous update of the workspace. The
+ * updated workspace is not available until processing completes. To check the status of the
+ * asynchronous operation, use the **Get information about a workspace** method.
+ *
+ * @param updateWorkspaceAsyncOptions the {@link UpdateWorkspaceAsyncOptions} containing the
+ * options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall updateWorkspaceAsync(
+ UpdateWorkspaceAsyncOptions updateWorkspaceAsyncOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ updateWorkspaceAsyncOptions, "updateWorkspaceAsyncOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", updateWorkspaceAsyncOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces_async/{workspace_id}", pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "updateWorkspaceAsync");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (updateWorkspaceAsyncOptions.append() != null) {
+ builder.query("append", String.valueOf(updateWorkspaceAsyncOptions.append()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ if (updateWorkspaceAsyncOptions.name() != null) {
+ contentJson.addProperty("name", updateWorkspaceAsyncOptions.name());
+ }
+ if (updateWorkspaceAsyncOptions.description() != null) {
+ contentJson.addProperty("description", updateWorkspaceAsyncOptions.description());
+ }
+ if (updateWorkspaceAsyncOptions.language() != null) {
+ contentJson.addProperty("language", updateWorkspaceAsyncOptions.language());
+ }
+ if (updateWorkspaceAsyncOptions.dialogNodes() != null) {
+ contentJson.add(
+ "dialog_nodes",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.dialogNodes()));
+ }
+ if (updateWorkspaceAsyncOptions.counterexamples() != null) {
+ contentJson.add(
+ "counterexamples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.counterexamples()));
+ }
+ if (updateWorkspaceAsyncOptions.metadata() != null) {
+ contentJson.add(
+ "metadata",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.metadata()));
+ }
+ if (updateWorkspaceAsyncOptions.learningOptOut() != null) {
+ contentJson.addProperty("learning_opt_out", updateWorkspaceAsyncOptions.learningOptOut());
+ }
+ if (updateWorkspaceAsyncOptions.systemSettings() != null) {
+ contentJson.add(
+ "system_settings",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.systemSettings()));
+ }
+ if (updateWorkspaceAsyncOptions.webhooks() != null) {
+ contentJson.add(
+ "webhooks",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.webhooks()));
+ }
+ if (updateWorkspaceAsyncOptions.intents() != null) {
+ contentJson.add(
+ "intents",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.intents()));
+ }
+ if (updateWorkspaceAsyncOptions.entities() != null) {
+ contentJson.add(
+ "entities",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateWorkspaceAsyncOptions.entities()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Export workspace asynchronously.
+ *
+ * Export the entire workspace asynchronously, including all workspace content.
+ *
+ *
A successful call to this method only initiates an asynchronous export. The exported JSON
+ * data is not available until processing completes. After the initial request is submitted, you
+ * can continue to poll by calling the same request again and checking the value of the **status**
+ * property. When processing has completed, the request returns the exported JSON data. Remember
+ * that the usual rate limits apply.
+ *
+ * @param exportWorkspaceAsyncOptions the {@link ExportWorkspaceAsyncOptions} containing the
+ * options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Workspace}
+ */
+ public ServiceCall exportWorkspaceAsync(
+ ExportWorkspaceAsyncOptions exportWorkspaceAsyncOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ exportWorkspaceAsyncOptions, "exportWorkspaceAsyncOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", exportWorkspaceAsyncOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces_async/{workspace_id}/export", pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "exportWorkspaceAsync");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (exportWorkspaceAsyncOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(exportWorkspaceAsyncOptions.includeAudit()));
+ }
+ if (exportWorkspaceAsyncOptions.sort() != null) {
+ builder.query("sort", String.valueOf(exportWorkspaceAsyncOptions.sort()));
+ }
+ if (exportWorkspaceAsyncOptions.verbose() != null) {
+ builder.query("verbose", String.valueOf(exportWorkspaceAsyncOptions.verbose()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * List intents.
+ *
+ * List the intents for a workspace.
+ *
+ * @param listIntentsOptions the {@link ListIntentsOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link IntentCollection}
+ */
+ public ServiceCall listIntents(ListIntentsOptions listIntentsOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ listIntentsOptions, "listIntentsOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", listIntentsOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/intents", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "listIntents");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (listIntentsOptions.export() != null) {
+ builder.query("export", String.valueOf(listIntentsOptions.export()));
+ }
+ if (listIntentsOptions.pageLimit() != null) {
+ builder.query("page_limit", String.valueOf(listIntentsOptions.pageLimit()));
+ }
+ if (listIntentsOptions.includeCount() != null) {
+ builder.query("include_count", String.valueOf(listIntentsOptions.includeCount()));
+ }
+ if (listIntentsOptions.sort() != null) {
+ builder.query("sort", String.valueOf(listIntentsOptions.sort()));
+ }
+ if (listIntentsOptions.cursor() != null) {
+ builder.query("cursor", String.valueOf(listIntentsOptions.cursor()));
+ }
+ if (listIntentsOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(listIntentsOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create intent.
+ *
+ * Create a new intent.
+ *
+ *
If you want to create multiple intents with a single API call, consider using the **[Update
+ * workspace](#update-workspace)** method instead.
+ *
+ * @param createIntentOptions the {@link CreateIntentOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Intent}
+ */
+ public ServiceCall createIntent(CreateIntentOptions createIntentOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ createIntentOptions, "createIntentOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", createIntentOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/intents", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "createIntent");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (createIntentOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(createIntentOptions.includeAudit()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ contentJson.addProperty("intent", createIntentOptions.intent());
+ if (createIntentOptions.description() != null) {
+ contentJson.addProperty("description", createIntentOptions.description());
+ }
+ if (createIntentOptions.examples() != null) {
+ contentJson.add(
+ "examples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createIntentOptions.examples()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Get intent.
+ *
+ * Get information about an intent, optionally including all intent content.
+ *
+ * @param getIntentOptions the {@link GetIntentOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Intent}
+ */
+ public ServiceCall getIntent(GetIntentOptions getIntentOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ getIntentOptions, "getIntentOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", getIntentOptions.workspaceId());
+ pathParamsMap.put("intent", getIntentOptions.intent());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/intents/{intent}", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "getIntent");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (getIntentOptions.export() != null) {
+ builder.query("export", String.valueOf(getIntentOptions.export()));
+ }
+ if (getIntentOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(getIntentOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Update intent.
+ *
+ * Update an existing intent with new or modified data. You must provide component objects
+ * defining the content of the updated intent.
+ *
+ *
If you want to update multiple intents with a single API call, consider using the **[Update
+ * workspace](#update-workspace)** method instead.
+ *
+ * @param updateIntentOptions the {@link UpdateIntentOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Intent}
+ */
+ public ServiceCall updateIntent(UpdateIntentOptions updateIntentOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ updateIntentOptions, "updateIntentOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", updateIntentOptions.workspaceId());
+ pathParamsMap.put("intent", updateIntentOptions.intent());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/intents/{intent}", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "updateIntent");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (updateIntentOptions.append() != null) {
+ builder.query("append", String.valueOf(updateIntentOptions.append()));
+ }
+ if (updateIntentOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(updateIntentOptions.includeAudit()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ if (updateIntentOptions.newIntent() != null) {
+ contentJson.addProperty("intent", updateIntentOptions.newIntent());
+ }
+ if (updateIntentOptions.newDescription() != null) {
+ contentJson.addProperty("description", updateIntentOptions.newDescription());
+ }
+ if (updateIntentOptions.newExamples() != null) {
+ contentJson.add(
+ "examples",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateIntentOptions.newExamples()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Delete intent.
+ *
+ * Delete an intent from a workspace.
+ *
+ * @param deleteIntentOptions the {@link DeleteIntentOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a void result
+ */
+ public ServiceCall deleteIntent(DeleteIntentOptions deleteIntentOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ deleteIntentOptions, "deleteIntentOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", deleteIntentOptions.workspaceId());
+ pathParamsMap.put("intent", deleteIntentOptions.intent());
+ RequestBuilder builder =
+ RequestBuilder.delete(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/intents/{intent}", pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "deleteIntent");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ ResponseConverter responseConverter = ResponseConverterUtils.getVoid();
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * List user input examples.
+ *
+ * List the user input examples for an intent, optionally including contextual entity mentions.
+ *
+ * @param listExamplesOptions the {@link ListExamplesOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link ExampleCollection}
+ */
+ public ServiceCall listExamples(ListExamplesOptions listExamplesOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ listExamplesOptions, "listExamplesOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", listExamplesOptions.workspaceId());
+ pathParamsMap.put("intent", listExamplesOptions.intent());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/intents/{intent}/examples",
+ pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "listExamples");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (listExamplesOptions.pageLimit() != null) {
+ builder.query("page_limit", String.valueOf(listExamplesOptions.pageLimit()));
+ }
+ if (listExamplesOptions.includeCount() != null) {
+ builder.query("include_count", String.valueOf(listExamplesOptions.includeCount()));
+ }
+ if (listExamplesOptions.sort() != null) {
+ builder.query("sort", String.valueOf(listExamplesOptions.sort()));
+ }
+ if (listExamplesOptions.cursor() != null) {
+ builder.query("cursor", String.valueOf(listExamplesOptions.cursor()));
+ }
+ if (listExamplesOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(listExamplesOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create user input example.
+ *
+ * Add a new user input example to an intent.
+ *
+ *
If you want to add multiple examples with a single API call, consider using the **[Update
+ * intent](#update-intent)** method instead.
+ *
+ * @param createExampleOptions the {@link CreateExampleOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a result of type {@link Example}
+ */
+ public ServiceCall createExample(CreateExampleOptions createExampleOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ createExampleOptions, "createExampleOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", createExampleOptions.workspaceId());
+ pathParamsMap.put("intent", createExampleOptions.intent());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/intents/{intent}/examples",
+ pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "createExample");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (createExampleOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(createExampleOptions.includeAudit()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ contentJson.addProperty("text", createExampleOptions.text());
+ if (createExampleOptions.mentions() != null) {
+ contentJson.add(
+ "mentions",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(createExampleOptions.mentions()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Get user input example.
+ *
+ * Get information about a user input example.
+ *
+ * @param getExampleOptions the {@link GetExampleOptions} containing the options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Example}
+ */
+ public ServiceCall getExample(GetExampleOptions getExampleOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ getExampleOptions, "getExampleOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", getExampleOptions.workspaceId());
+ pathParamsMap.put("intent", getExampleOptions.intent());
+ pathParamsMap.put("text", getExampleOptions.text());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/intents/{intent}/examples/{text}",
+ pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "getExample");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (getExampleOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(getExampleOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Update user input example.
+ *
+ * Update the text of a user input example.
+ *
+ *
If you want to update multiple examples with a single API call, consider using the **[Update
+ * intent](#update-intent)** method instead.
+ *
+ * @param updateExampleOptions the {@link UpdateExampleOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a result of type {@link Example}
+ */
+ public ServiceCall updateExample(UpdateExampleOptions updateExampleOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ updateExampleOptions, "updateExampleOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", updateExampleOptions.workspaceId());
+ pathParamsMap.put("intent", updateExampleOptions.intent());
+ pathParamsMap.put("text", updateExampleOptions.text());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/intents/{intent}/examples/{text}",
+ pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "updateExample");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (updateExampleOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(updateExampleOptions.includeAudit()));
+ }
+ final JsonObject contentJson = new JsonObject();
+ if (updateExampleOptions.newText() != null) {
+ contentJson.addProperty("text", updateExampleOptions.newText());
+ }
+ if (updateExampleOptions.newMentions() != null) {
+ contentJson.add(
+ "mentions",
+ com.ibm.cloud.sdk.core.util.GsonSingleton.getGson()
+ .toJsonTree(updateExampleOptions.newMentions()));
+ }
+ builder.bodyJson(contentJson);
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Delete user input example.
+ *
+ * Delete a user input example from an intent.
+ *
+ * @param deleteExampleOptions the {@link DeleteExampleOptions} containing the options for the
+ * call
+ * @return a {@link ServiceCall} with a void result
+ */
+ public ServiceCall deleteExample(DeleteExampleOptions deleteExampleOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ deleteExampleOptions, "deleteExampleOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", deleteExampleOptions.workspaceId());
+ pathParamsMap.put("intent", deleteExampleOptions.intent());
+ pathParamsMap.put("text", deleteExampleOptions.text());
+ RequestBuilder builder =
+ RequestBuilder.delete(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(),
+ "/v1/workspaces/{workspace_id}/intents/{intent}/examples/{text}",
+ pathParamsMap));
+ Map sdkHeaders = SdkCommon.getSdkHeaders("conversation", "v1", "deleteExample");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ ResponseConverter responseConverter = ResponseConverterUtils.getVoid();
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * List counterexamples.
+ *
+ * List the counterexamples for a workspace. Counterexamples are examples that have been marked
+ * as irrelevant input.
+ *
+ * @param listCounterexamplesOptions the {@link ListCounterexamplesOptions} containing the options
+ * for the call
+ * @return a {@link ServiceCall} with a result of type {@link CounterexampleCollection}
+ */
+ public ServiceCall listCounterexamples(
+ ListCounterexamplesOptions listCounterexamplesOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ listCounterexamplesOptions, "listCounterexamplesOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", listCounterexamplesOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.get(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/counterexamples", pathParamsMap));
+ Map sdkHeaders =
+ SdkCommon.getSdkHeaders("conversation", "v1", "listCounterexamples");
+ for (Entry header : sdkHeaders.entrySet()) {
+ builder.header(header.getKey(), header.getValue());
+ }
+ builder.header("Accept", "application/json");
+ builder.query("version", String.valueOf(this.version));
+ if (listCounterexamplesOptions.pageLimit() != null) {
+ builder.query("page_limit", String.valueOf(listCounterexamplesOptions.pageLimit()));
+ }
+ if (listCounterexamplesOptions.includeCount() != null) {
+ builder.query("include_count", String.valueOf(listCounterexamplesOptions.includeCount()));
+ }
+ if (listCounterexamplesOptions.sort() != null) {
+ builder.query("sort", String.valueOf(listCounterexamplesOptions.sort()));
+ }
+ if (listCounterexamplesOptions.cursor() != null) {
+ builder.query("cursor", String.valueOf(listCounterexamplesOptions.cursor()));
+ }
+ if (listCounterexamplesOptions.includeAudit() != null) {
+ builder.query("include_audit", String.valueOf(listCounterexamplesOptions.includeAudit()));
+ }
+ ResponseConverter responseConverter =
+ ResponseConverterUtils.getValue(
+ new com.google.gson.reflect.TypeToken() {}.getType());
+ return createServiceCall(builder.build(), responseConverter);
+ }
+
+ /**
+ * Create counterexample.
+ *
+ * Add a new counterexample to a workspace. Counterexamples are examples that have been marked
+ * as irrelevant input.
+ *
+ *
If you want to add multiple counterexamples with a single API call, consider using the
+ * **[Update workspace](#update-workspace)** method instead.
+ *
+ * @param createCounterexampleOptions the {@link CreateCounterexampleOptions} containing the
+ * options for the call
+ * @return a {@link ServiceCall} with a result of type {@link Counterexample}
+ */
+ public ServiceCall createCounterexample(
+ CreateCounterexampleOptions createCounterexampleOptions) {
+ com.ibm.cloud.sdk.core.util.Validator.notNull(
+ createCounterexampleOptions, "createCounterexampleOptions cannot be null");
+ Map pathParamsMap = new HashMap();
+ pathParamsMap.put("workspace_id", createCounterexampleOptions.workspaceId());
+ RequestBuilder builder =
+ RequestBuilder.post(
+ RequestBuilder.resolveRequestUrl(
+ getServiceUrl(), "/v1/workspaces/{workspace_id}/counterexamples", pathParamsMap));
+ Map
- To then update all version numbers, simply run:
+- After doing this with all of the necessary packages, you can verify that things worked by checking the available versions on [Maven Central](https://search.maven.org/search?q=com.ibm.watson). This could take up to an hour.
- ```bash
- bumpversion major|minor|patch
- ```
+### Unsuccessful Bintray deployment
- 1. Perform a release deployment to OSSRH (Staging) with:
+This case is much more unlikely, since integration tests don't run on `master` and builds are very unlikely to be passing in a PR but fail once it's merged. Nevertheless, if this does happen and files aren't deployed to Bintray, you'll need to follow some steps to do this manually:
- ```bash
- `gradle release`
- ```
+- Navigate to the code on Bintray at [this URL](https://bintray.com/ibm-cloud-sdks/ibm-cloud-sdk-repo). If you're not a member of the ibm-cloud-sdks organization, ask the maintainer of this SDK repo for access.
+- For each package in the SDK, if the new version isn't present, you can add it by navigating to the package and adding it manually:
- You will have to answer prompts for versions and tags. That will tag and commit a new version into your repository automatically.
+ 
-[bumpversion]: https://pypi.python.org/pypi/bumpversion
+- To add the files, make sure to first generate all of the necessary artifacts locally. Check out the new release tag and generate them with the following commands (from the SDK repo):
+ ```
+ git checkout {release tag}
+ ./gradlew shadowJar
+ ```
+- In the new version of the package on Bintray, add the files with the "Upload Files" button. Follow the file structure of previous releases to ensure everything works properly. The files to add should be in the `build/libs` folder of each local package in the SDK.
-### Manually releasing
+ 
-The above steps should work, but we've run into situations where the archive uploading through CI has failed because IP changes caused multiple staging repositories to be created in Sonatype, each with different pieces of the full set of artifacts. If this happens, the repositories won't be able to be closed and released on the Sonatype website.
-
-Uploading the archives locally with the following command solves this problem:
-
-```bash
-./gradlew uploadArchives -Psigning.keyId=