diff --git a/Conductor/Api/ITaskResourceApi.cs b/Conductor/Api/ITaskResourceApi.cs
index d0e59d5..e54cded 100644
--- a/Conductor/Api/ITaskResourceApi.cs
+++ b/Conductor/Api/ITaskResourceApi.cs
@@ -213,6 +213,22 @@ public interface ITaskResourceApi : IApiAccessor
         /// <returns>string</returns>
         string UpdateTask(Dictionary<string, Object> body, string workflowId, string taskRefName, string status, string workerid = null);
 
+        /// <summary>
+        /// Update a task By Ref Name, evaluates the workflow and returns the updated workflow
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="output"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="taskRefName"></param>
+        /// <param name="status"></param>
+        /// <param name="workerid"> (optional)</param>
+        /// <returns>Workflow</returns>
+        Workflow UpdateTaskSync(Dictionary<string, Object> output, string workflowId, string taskRefName, TaskResult.StatusEnum status, string workerid = null);
+
+
         #endregion Synchronous Operations
 
         #region Asynchronous Operations
@@ -415,6 +431,22 @@ public interface ITaskResourceApi : IApiAccessor
         /// <param name="workerid"> (optional)</param>
         /// <returns>string</returns>
         ThreadTask.Task<string> UpdateTaskAsync(Dictionary<string, Object> body, string workflowId, string taskRefName, string status, string workerid = null);
+
+        /// <summary>
+        /// Update a task By Ref Name, evaluates the workflow and returns the updated workflow
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="output"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="taskRefName"></param>
+        /// <param name="status"></param>
+        /// <param name="workerid"> (optional)</param>
+        /// <returns>Workflow</returns>
+        ThreadTask.Task<Workflow> UpdateTaskSyncAsync(Dictionary<string, Object> output, string workflowId, string taskRefName, TaskResult.StatusEnum status, string workerid = null);
+
         #endregion Asynchronous Operations
     }
 }
diff --git a/Conductor/Api/IWorkflowResourceApi.cs b/Conductor/Api/IWorkflowResourceApi.cs
index 3eb3770..0d83808 100644
--- a/Conductor/Api/IWorkflowResourceApi.cs
+++ b/Conductor/Api/IWorkflowResourceApi.cs
@@ -55,9 +55,11 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <summary>
         /// Update the value of the workflow variables for the given workflow id 
         /// </summary>
-        /// <param name="workflow"></param>
-        /// <returns>ApiResponse of Object(void)</returns>
-        Object UpdateWorkflowVariables(Workflow workflow);
+        /// <param name="workflowId"></param>
+        /// <param name="variables"></param>
+        /// <returns>Workflow</returns>
+        Workflow UpdateWorkflowVariables(string workflowId, Dictionary<string, Object> variables);
+
         /// <summary>
         /// Gets the workflow by workflow id
         /// </summary>
@@ -71,6 +73,18 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <returns>Workflow</returns>
         Workflow GetExecutionStatus(string workflowId, bool? includeTasks = null, bool? summarize = null);
 
+        /// <summary>
+        /// Gets the workflow by workflow id
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="workflowId"></param>
+        /// <param name="includeTasks"> (optional, default to true)</param>
+        /// <returns>Workflow</returns>
+        Workflow GetWorkflow(string workflowId, bool? includeTasks = null);
+
         /// <summary>
         /// Gets the workflow tasks by workflow id
         /// </summary>
@@ -384,6 +398,18 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <returns>Object</returns>
         Object UploadCompletedWorkflows();
 
+        /// <summary>
+        /// Update a workflow state by updating variables or in progress task Updates the workflow variables, tasks and triggers evaluation.
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="request"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="waitUntilTaskRefs"> (optional)</param>
+        /// <param name="waitForSeconds"> (optional, default to 10)</param>
+        /// <returns>WorkflowRun</returns>
+        WorkflowRun UpdateWorkflow(string workflowId, WorkflowStateUpdate request,
+            List<string> waitUntilTaskRefs = null, int? waitForSeconds = null);
+
         #endregion Synchronous Operations
 
         #region Asynchronous Operations
@@ -428,9 +454,11 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <summary>
         /// Asynchronous Update the value of the workflow variables for the given workflow id 
         /// </summary>
-        /// <param name="workflow"></param>
-        /// <returns>ApiResponse of Object(void)</returns>
-        ThreadTask.Task<Object> UpdateWorkflowVariablesAsync(Workflow workflow);
+        /// <param name="workflowId"></param>
+        /// /// <param name="variables"></param>
+        /// <returns>Workflow</returns>
+        ThreadTask.Task<Workflow> UpdateWorkflowVariablesAsync(string workflowId, Dictionary<string, Object> variables);
+
 
         /// <summary>
         /// Asynchronous Gets the workflow by workflow id
@@ -445,6 +473,18 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <returns>Workflow</returns>
         ThreadTask.Task<Workflow> GetExecutionStatusAsync(string workflowId, bool? includeTasks = null, bool? summarize = null);
 
+        /// <summary>
+        /// Asynchronous Gets the workflow by workflow id
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="workflowId"></param>
+        /// <param name="includeTasks"> (optional, default to true)</param>
+        /// <returns>Workflow</returns>
+        ThreadTask.Task<Workflow> GetWorkflowAsync(string workflowId, bool? includeTasks = null);
+
         /// <summary>
         /// Asynchronous Gets the workflow tasks by workflow id
         /// </summary>
@@ -758,6 +798,18 @@ public interface IWorkflowResourceApi : IApiAccessor
         /// <returns>Object</returns>
         ThreadTask.Task<Object> UploadCompletedWorkflowsAsync();
 
+        /// <summary>
+        /// Update a workflow state by updating variables or in progress task Updates the workflow variables, tasks and triggers evaluation.
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="request"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="waitUntilTaskRefs"> (optional)</param>
+        /// <param name="waitForSeconds"> (optional, default to 10)</param>
+        /// <returns>WorkflowRun</returns>
+        ThreadTask.Task<WorkflowRun> UpdateWorkflowAsync(string workflowId, WorkflowStateUpdate request,
+            List<string> waitUntilTaskRefs = null, int? waitForSeconds = null);
+
         #endregion Asynchronous Operations
     }
 }
diff --git a/Conductor/Api/TaskResourceApi.cs b/Conductor/Api/TaskResourceApi.cs
index 4b8e0c7..aa2fa3d 100644
--- a/Conductor/Api/TaskResourceApi.cs
+++ b/Conductor/Api/TaskResourceApi.cs
@@ -1532,14 +1532,131 @@ public ApiResponse<string> UpdateTaskWithHttpInfo(Dictionary<string, Object> bod
               (string)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(string)));
         }
 
-        // public ExternalStorageLocation GetExternalStorageLocation(string path, string operation, string payloadType)
-        // {
-        //   throw new NotImplementedException();
-        // }
-
-        // public ApiResponse<ExternalStorageLocation> GetExternalStorageLocationWithHttpInfo(string path, string operation, string payloadType)
-        // {
-        //   throw new NotImplementedException();
-        // }
+        /// <summary>
+        /// Update a task By Ref Name, evaluates the workflow and returns the updated workflow
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="output"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="taskRefName"></param>
+        /// <param name="status"></param>
+        /// <param name="workerid"> (optional)</param>
+        /// <returns>Workflow</returns>
+        public Workflow UpdateTaskSync(Dictionary<string, Object> output, string workflowId, string taskRefName,
+            TaskResult.StatusEnum status, string workerid = null)
+        {
+            var response = UpdateTaskSyncWithHttpInfo(output, workflowId, taskRefName, status, workerid);
+            return response.Data;
+        }
+
+        /// <summary>
+        /// Update a task By Ref Name, evaluates the workflow and returns the updated workflow
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="output"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="taskRefName"></param>
+        /// <param name="status"></param>
+        /// <param name="workerid"> (optional)</param>
+        /// <returns>Workflow</returns>
+        public async ThreadTask.Task<Workflow> UpdateTaskSyncAsync(Dictionary<string, Object> output, string workflowId,
+            string taskRefName, TaskResult.StatusEnum status, string workerid = null)
+        {
+            ApiResponse<Workflow> localVarResponse = await ThreadTask.Task.FromResult(UpdateTaskSyncWithHttpInfo(output, workflowId, taskRefName, status, workerid));
+            return localVarResponse.Data;
+        }
+
+        /// <summary>
+        /// Update a task By Ref Name 
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="output"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="taskRefName"></param>
+        /// <param name="status"></param>
+        /// <returns>ApiResponse of string</returns>
+        public ApiResponse<Workflow> UpdateTaskSyncWithHttpInfo(Dictionary<string, Object> output, string workflowId, string taskRefName, TaskResult.StatusEnum status, string workerid = null)
+        {
+            // verify the required parameter 'body' is set
+            if (output == null)
+                throw new ApiException(400, "Missing required parameter 'body' when calling TaskResourceApi->UpdateTask");
+            // verify the required parameter 'workflowId' is set
+            if (workflowId == null)
+                throw new ApiException(400, "Missing required parameter 'workflowId' when calling TaskResourceApi->UpdateTask");
+            // verify the required parameter 'taskRefName' is set
+            if (taskRefName == null)
+                throw new ApiException(400, "Missing required parameter 'taskRefName' when calling TaskResourceApi->UpdateTask");
+            // verify the required parameter 'status' is set
+            if (status == null)
+                throw new ApiException(400, "Missing required parameter 'status' when calling TaskResourceApi->UpdateTask");
+
+            var localVarPath = "/tasks/{workflowId}/{taskRefName}/{status}/sync";
+            var localVarPathParams = new Dictionary<String, String>();
+            var localVarQueryParams = new List<KeyValuePair<String, String>>();
+            var localVarHeaderParams = new Dictionary<String, String>(this.Configuration.DefaultHeader);
+            var localVarFormParams = new Dictionary<String, String>();
+            var localVarFileParams = new Dictionary<String, FileParameter>();
+            Object localVarPostBody = null;
+
+            // to determine the Content-Type header
+            String[] localVarHttpContentTypes = new String[] {
+                "application/json"
+            };
+            String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
+
+            // to determine the Accept header
+            String[] localVarHttpHeaderAccepts = new String[] {
+                "text/plain"
+            };
+            String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
+            if (localVarHttpHeaderAccept != null)
+                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
+
+            if (workerid == null)
+            {
+                workerid = Environment.MachineName;
+            }
+
+            if (workflowId != null) localVarPathParams.Add("workflowId", this.Configuration.ApiClient.ParameterToString(workflowId)); // path parameter
+            if (taskRefName != null) localVarPathParams.Add("taskRefName", this.Configuration.ApiClient.ParameterToString(taskRefName)); // path parameter
+            if (status != null) localVarPathParams.Add("status", this.Configuration.ApiClient.ParameterToString(status)); // path parameter
+            if (workerid != null) localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "workerid", workerid)); // query parameter
+            if (output != null && output.GetType() != typeof(byte[]))
+            {
+                localVarPostBody = this.Configuration.ApiClient.Serialize(output); // http body (model) parameter
+            }
+            else
+            {
+                localVarPostBody = output; // byte array
+            }
+            // authentication (api_key) required
+            if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
+            {
+                localVarHeaderParams["X-Authorization"] = this.Configuration.AccessToken;
+            }
+
+            // make the HTTP request
+            RestResponse localVarResponse = (RestResponse)this.Configuration.ApiClient.CallApi(localVarPath,
+                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
+                localVarPathParams, localVarHttpContentType);
+
+            int localVarStatusCode = (int)localVarResponse.StatusCode;
+
+            if (ExceptionFactory != null)
+            {
+                Exception exception = ExceptionFactory("UpdateTask", localVarResponse);
+                if (exception != null) throw exception;
+            }
+
+            return new ApiResponse<Workflow>(localVarStatusCode,
+                localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
+                (Workflow)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Workflow)));
+        }
     }
 }
diff --git a/Conductor/Api/WorkflowResourceApi.cs b/Conductor/Api/WorkflowResourceApi.cs
index b8baf2c..2f5dca4 100644
--- a/Conductor/Api/WorkflowResourceApi.cs
+++ b/Conductor/Api/WorkflowResourceApi.cs
@@ -365,43 +365,45 @@ public ApiResponse<WorkflowRun> ExecuteWorkflowWithHttpInfo(StartWorkflowRequest
         /// <summary>
         /// Update the Workflow variables synchronously
         /// </summary>
-        /// <param name="workflow"></param>
-        /// <returns></returns>
-        public Object UpdateWorkflowVariables(Workflow workflow)
+        /// <param name="workflowId"></param>
+        /// <param name="variables"></param>
+        /// <returns>Workflow</returns>
+        public Workflow UpdateWorkflowVariables(string workflowId, Dictionary<string, Object> variables)
         {
-            ApiResponse<Object> localVarResponse = UpdateWorkflowVariablesWithHttpInfo(workflow);
+            ApiResponse<Workflow> localVarResponse = UpdateWorkflowVariablesWithHttpInfo(workflowId, variables);
             return localVarResponse.Data;
         }
 
         /// <summary>
         /// Asynchronous Update the Workflow variables
         /// </summary>
-        /// <param name="workflow"></param>
-        /// <returns></returns>
-        public async ThreadTask.Task<Object> UpdateWorkflowVariablesAsync(Workflow workflow)
+        /// <param name="workflowId"></param>
+        /// <param name="variables"></param>
+        /// <returns>Workflow</returns>
+        public async ThreadTask.Task<Workflow> UpdateWorkflowVariablesAsync(string workflowId, Dictionary<string, Object> variables)
         {
-            ApiResponse<Object> localVarResponse = await ThreadTask.Task.FromResult(UpdateWorkflowVariablesWithHttpInfo(workflow));
+            ApiResponse<Workflow> localVarResponse = await ThreadTask.Task.FromResult(UpdateWorkflowVariablesWithHttpInfo(workflowId, variables));
             return localVarResponse.Data;
         }
 
         /// <summary>
         /// Update the Workflow variables 
         /// </summary>
-        /// <param name="workflow"></param>
-        /// <returns></returns>
-        public ApiResponse<Object> UpdateWorkflowVariablesWithHttpInfo(Workflow workflow)
+        /// <param name="workflowId"></param>
+        /// <param name="variables"></param>
+        /// <returns>Workflow</returns>
+        public ApiResponse<Workflow> UpdateWorkflowVariablesWithHttpInfo(string workflowId, Dictionary<string, Object> variables)
         {
             // verify the required parameter 'body' is set
-            if (workflow == null)
-                throw new ApiException(400, "Missing required parameter 'body' when calling WorkflowResourceApi->Update");
+            if (workflowId == null)
+                throw new ApiException(400, "Missing required parameter 'workflowId' when calling WorkflowResourceApi->UpdateWorkflowVariables");
 
-            if (string.IsNullOrEmpty(workflow.WorkflowId))
-                throw new ApiException(400, "Missing required parameter 'WorkflowId' when calling WorkflowResourceApi->Update");
 
-            if (workflow.Variables == null)
-                throw new ApiException(400, "Missing required parameter 'Variables' when calling WorkflowResourceApi->Update");
 
-            var localVarPath = $"/workflow/{workflow.WorkflowId}/variables";
+            if (variables == null)
+                throw new ApiException(400, "Missing required parameter 'variables' when calling WorkflowResourceApi->UpdateWorkflowVariables");
+
+            var localVarPath = $"/workflow/{workflowId}/variables";
             var localVarPathParams = new Dictionary<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(this.Configuration.DefaultHeader);
@@ -411,22 +413,19 @@ public ApiResponse<Object> UpdateWorkflowVariablesWithHttpInfo(Workflow workflow
 
             // to determine the Content-Type header
             String[] localVarHttpContentTypes = new String[] {
-      "application/json"
-    };
+                "application/json"
+            };
             String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
 
             // to determine the Accept header
             String[] localVarHttpHeaderAccepts = new String[] {
-      "*/*"
-    };
+                "*/*"
+            };
             String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
             if (localVarHttpHeaderAccept != null)
                 localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
 
-            if (workflow != null && workflow.GetType() != typeof(byte[]))
-            {
-                localVarPostBody = this.Configuration.ApiClient.Serialize(workflow.Variables);
-            }
+            localVarPostBody = this.Configuration.ApiClient.Serialize(variables);
 
             // authentication (api_key) required
             if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
@@ -434,9 +433,11 @@ public ApiResponse<Object> UpdateWorkflowVariablesWithHttpInfo(Workflow workflow
                 localVarHeaderParams["X-Authorization"] = this.Configuration.AccessToken;
             }
 
+            // make the HTTP request
             RestResponse localVarResponse = (RestResponse)this.Configuration.ApiClient.CallApi(localVarPath,
-              Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
-              localVarPathParams, localVarHttpContentType);
+                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
+                localVarPathParams, localVarHttpContentType);
+
             int localVarStatusCode = (int)localVarResponse.StatusCode;
 
             if (ExceptionFactory != null)
@@ -445,9 +446,9 @@ public ApiResponse<Object> UpdateWorkflowVariablesWithHttpInfo(Workflow workflow
                 if (exception != null) throw exception;
             }
 
-            return new ApiResponse<Object>(localVarStatusCode,
-              localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
-              (Object)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Object)));
+            return new ApiResponse<Workflow>(localVarStatusCode,
+                localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
+                (Workflow)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Workflow)));
         }
 
         /// <summary>
@@ -464,6 +465,19 @@ public Workflow GetExecutionStatus(string workflowId, bool? includeTasks = null,
             return localVarResponse.Data;
         }
 
+        /// <summary>
+        /// Gets the workflow by workflow id 
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="workflowId"></param>
+        /// <param name="includeTasks"> (optional, default to true)</param>
+        /// <param name="summarize"> (optional, default to false)</param>
+        /// <returns>Workflow</returns>
+        public Workflow GetWorkflow(string workflowId, bool? includeTasks = null)
+        {
+            return GetExecutionStatus(workflowId, includeTasks);
+        }
+
 
         /// <summary>
         /// Asynchronous Gets the workflow by workflow id 
@@ -479,6 +493,19 @@ public async ThreadTask.Task<Workflow> GetExecutionStatusAsync(string workflowId
             return localVarResponse.Data;
         }
 
+        /// <summary>
+        /// Asynchronous Gets the workflow by workflow id 
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="workflowId"></param>
+        /// <param name="includeTasks"> (optional, default to true)</param>
+        /// <param name="summarize"> (optional, default to false)</param>
+        /// <returns>Workflow</returns>
+        public async ThreadTask.Task<Workflow> GetWorkflowAsync(string workflowId, bool? includeTasks = null)
+        {
+            return await GetExecutionStatusAsync(workflowId, includeTasks);
+        }
+
 
         /// <summary>
         /// Gets the workflow by workflow id 
@@ -2713,13 +2740,13 @@ public ApiResponse<Object> UploadCompletedWorkflowsWithHttpInfo()
 
             // to determine the Content-Type header
             String[] localVarHttpContentTypes = new String[] {
-    };
+            };
             String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
 
             // to determine the Accept header
             String[] localVarHttpHeaderAccepts = new String[] {
-      "*/*"
-    };
+                "*/*"
+            };
             String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
             if (localVarHttpHeaderAccept != null)
                 localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
@@ -2747,5 +2774,121 @@ public ApiResponse<Object> UploadCompletedWorkflowsWithHttpInfo()
               localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
               (Object)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Object)));
         }
+
+        /// <summary>
+        /// Update a workflow state by updating variables or in progress task Updates the workflow variables, tasks and triggers evaluation.
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="request"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="waitUntilTaskRefs"> (optional)</param>
+        /// <param name="waitForSeconds"> (optional, default to 10)</param>
+        /// <returns>WorkflowRun</returns>
+        public WorkflowRun UpdateWorkflow(string workflowId, WorkflowStateUpdate request,
+            List<string> waitUntilTaskRefs = null, int? waitForSeconds = null)
+        {
+            var response = UpdateWorkflowWithHttpInfo(workflowId, request, waitUntilTaskRefs, waitForSeconds);
+            return response.Data;
+        }
+        /// <summary>
+        /// Update a workflow state by updating variables or in progress task Updates the workflow variables, tasks and triggers evaluation.
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="request"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="waitUntilTaskRefs"> (optional)</param>
+        /// <param name="waitForSeconds"> (optional, default to 10)</param>
+        /// <returns>WorkflowRun</returns>
+        public async ThreadTask.Task<WorkflowRun> UpdateWorkflowAsync(string workflowId, WorkflowStateUpdate request,
+            List<string> waitUntilTaskRefs = null, int? waitForSeconds = null)
+        {
+            ApiResponse<WorkflowRun> localVarResponse = await ThreadTask.Task.FromResult(UpdateWorkflowWithHttpInfo(workflowId, request, waitUntilTaskRefs, waitForSeconds));
+            return localVarResponse.Data;
+        }
+
+        /// <summary>
+        /// Update a workflow state by updating variables or in progress task Updates the workflow variables, tasks and triggers evaluation.
+        /// </summary>
+        /// <exception cref="Conductor.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="request"></param>
+        /// <param name="workflowId"></param>
+        /// <param name="waitUntilTaskRefs"> (optional)</param>
+        /// <param name="waitForSeconds"> (optional, default to 10)</param>
+        /// <returns>ApiResponse of WorkflowRun</returns>
+        public ApiResponse<WorkflowRun> UpdateWorkflowWithHttpInfo(string workflowId, WorkflowStateUpdate request,
+            List<string> waitUntilTaskRefs = null, int? waitForSeconds = null)
+        {
+            string requestId = Guid.NewGuid().ToString();
+            string waitUntilTaskRef = waitUntilTaskRefs != null && waitUntilTaskRefs.Count > 0 ?
+                waitUntilTaskRefs.Aggregate((a, b) => a + ", " + b) : null;
+
+            // verify the required parameter 'request' is set
+            if (request == null)
+                throw new ApiException(400, "Missing required parameter 'request' when calling WorkflowResourceApi->UpdateWorkflowAndTaskState");
+            // verify the required parameter 'requestId' is set
+            if (requestId == null)
+                throw new ApiException(400, "Missing required parameter 'requestId' when calling WorkflowResourceApi->UpdateWorkflowAndTaskState");
+            // verify the required parameter 'workflowId' is set
+            if (workflowId == null)
+                throw new ApiException(400, "Missing required parameter 'workflowId' when calling WorkflowResourceApi->UpdateWorkflowAndTaskState");
+
+            var localVarPath = "/workflow/{workflowId}/state";
+            var localVarPathParams = new Dictionary<String, String>();
+            var localVarQueryParams = new List<KeyValuePair<String, String>>();
+            var localVarHeaderParams = new Dictionary<String, String>(this.Configuration.DefaultHeader);
+            var localVarFormParams = new Dictionary<String, String>();
+            var localVarFileParams = new Dictionary<String, FileParameter>();
+            Object localVarPostBody = null;
+
+            // to determine the Content-Type header
+            String[] localVarHttpContentTypes = new String[] {
+                "application/json"
+            };
+            String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
+
+            // to determine the Accept header
+            String[] localVarHttpHeaderAccepts = new String[] {
+                "*/*"
+            };
+            String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
+            if (localVarHttpHeaderAccept != null)
+                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
+
+            if (workflowId != null) localVarPathParams.Add("workflowId", this.Configuration.ApiClient.ParameterToString(workflowId)); // path parameter
+            if (requestId != null) localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "requestId", requestId)); // query parameter
+            if (waitUntilTaskRef != null) localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "waitUntilTaskRef", waitUntilTaskRef)); // query parameter
+            if (waitForSeconds != null) localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "waitForSeconds", waitForSeconds)); // query parameter
+            if (request != null && request.GetType() != typeof(byte[]))
+            {
+                localVarPostBody = this.Configuration.ApiClient.Serialize(request); // http body (model) parameter
+            }
+            else
+            {
+                localVarPostBody = request; // byte array
+            }
+
+            // authentication (api_key) required
+            if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
+            {
+                localVarHeaderParams["X-Authorization"] = this.Configuration.AccessToken;
+            }
+
+            // make the HTTP request
+            RestResponse localVarResponse = (RestResponse)this.Configuration.ApiClient.CallApi(localVarPath,
+                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
+                localVarPathParams, localVarHttpContentType);
+
+            int localVarStatusCode = (int)localVarResponse.StatusCode;
+
+            if (ExceptionFactory != null)
+            {
+                Exception exception = ExceptionFactory("UpdateWorkflowAndTaskState", localVarResponse);
+                if (exception != null) throw exception;
+            }
+
+            return new ApiResponse<WorkflowRun>(localVarStatusCode,
+                localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
+                (WorkflowRun)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(WorkflowRun)));
+        }
     }
 }
\ No newline at end of file
diff --git a/Conductor/Client/Models/IdempotencyStrategy.cs b/Conductor/Client/Models/IdempotencyStrategy.cs
new file mode 100644
index 0000000..7d44f46
--- /dev/null
+++ b/Conductor/Client/Models/IdempotencyStrategy.cs
@@ -0,0 +1,15 @@
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace Conductor.Client.Models
+{
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum IdempotencyStrategy
+    {
+        [EnumMember(Value = "FAIL")]
+        FAIL = 0,
+        [EnumMember(Value = "RETURN_EXISTING")]
+        RETURN_EXISTING = 1
+    }
+}
\ No newline at end of file
diff --git a/Conductor/Client/Models/StartWorkflowRequest.cs b/Conductor/Client/Models/StartWorkflowRequest.cs
index 013751e..6fb62e7 100644
--- a/Conductor/Client/Models/StartWorkflowRequest.cs
+++ b/Conductor/Client/Models/StartWorkflowRequest.cs
@@ -1,22 +1,21 @@
-using System.Linq;
-using System.IO;
 using System;
-using System.Text;
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using System.Runtime.Serialization;
+using System.Text;
 using Newtonsoft.Json;
-using System.ComponentModel.DataAnnotations;
 
 namespace Conductor.Client.Models
 {
     /// <summary>
-    /// StartWorkflowRequest
+    ///     StartWorkflowRequest
     /// </summary>
     [DataContract]
-    public partial class StartWorkflowRequest : IEquatable<StartWorkflowRequest>, IValidatableObject
+    public class StartWorkflowRequest : IEquatable<StartWorkflowRequest>, IValidatableObject
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="StartWorkflowRequest" /> class.
+        ///     Initializes a new instance of the <see cref="StartWorkflowRequest" /> class.
         /// </summary>
         /// <param name="correlationId">correlationId.</param>
         /// <param name="createdBy">createdBy.</param>
@@ -27,17 +26,14 @@ public partial class StartWorkflowRequest : IEquatable<StartWorkflowRequest>, IV
         /// <param name="taskToDomain">taskToDomain.</param>
         /// <param name="version">version.</param>
         /// <param name="workflowDef">workflowDef.</param>
-        public StartWorkflowRequest(string correlationId = default(string), string createdBy = default(string), string externalInputPayloadStoragePath = default(string), Dictionary<string, Object> input = default(Dictionary<string, Object>), string name = default(string), int? priority = default(int?), Dictionary<string, string> taskToDomain = default(Dictionary<string, string>), int? version = default(int?), WorkflowDef workflowDef = default(WorkflowDef))
+        public StartWorkflowRequest(string correlationId = default, string createdBy = default,
+            string externalInputPayloadStoragePath = default, Dictionary<string, object> input = default,
+            string name = default, int? priority = default, Dictionary<string, string> taskToDomain = default,
+            int? version = default, WorkflowDef workflowDef = default,
+            string idempotencyKey = default(string),
+            IdempotencyStrategy idempotencyStrategy = IdempotencyStrategy.FAIL)
         {
-            // to ensure "name" is required (not null)
-            if (name == null)
-            {
-                throw new InvalidDataException("name is a required property for StartWorkflowRequest and cannot be null");
-            }
-            else
-            {
-                this.Name = name;
-            }
+            this.Name = name;
             this.CorrelationId = correlationId;
             this.CreatedBy = createdBy;
             this.ExternalInputPayloadStoragePath = externalInputPayloadStoragePath;
@@ -46,64 +42,142 @@ public partial class StartWorkflowRequest : IEquatable<StartWorkflowRequest>, IV
             this.TaskToDomain = taskToDomain;
             this.Version = version;
             this.WorkflowDef = workflowDef;
+            this.IdempotencyKey = idempotencyKey;
+            this.IdempotencyStrategy = idempotencyStrategy;
         }
 
+        [DataMember(Name = "idempotencyStrategy", EmitDefaultValue = true)]
+        public IdempotencyStrategy IdempotencyStrategy { get; set; }
+
+        [DataMember(Name = "idempotencyKey", EmitDefaultValue = false)]
+        public string IdempotencyKey { get; set; }
+
         /// <summary>
-        /// Gets or Sets CorrelationId
+        ///     Gets or Sets CorrelationId
         /// </summary>
         [DataMember(Name = "correlationId", EmitDefaultValue = false)]
         public string CorrelationId { get; set; }
 
         /// <summary>
-        /// Gets or Sets CreatedBy
+        ///     Gets or Sets CreatedBy
         /// </summary>
         [DataMember(Name = "createdBy", EmitDefaultValue = false)]
         public string CreatedBy { get; set; }
 
         /// <summary>
-        /// Gets or Sets ExternalInputPayloadStoragePath
+        ///     Gets or Sets ExternalInputPayloadStoragePath
         /// </summary>
         [DataMember(Name = "externalInputPayloadStoragePath", EmitDefaultValue = false)]
         public string ExternalInputPayloadStoragePath { get; set; }
 
         /// <summary>
-        /// Gets or Sets Input
+        ///     Gets or Sets Input
         /// </summary>
         [DataMember(Name = "input", EmitDefaultValue = false)]
-        public Dictionary<string, Object> Input { get; set; }
+        public Dictionary<string, object> Input { get; set; }
 
         /// <summary>
-        /// Gets or Sets Name
+        ///     Gets or Sets Name
         /// </summary>
         [DataMember(Name = "name", EmitDefaultValue = false)]
         public string Name { get; set; }
 
         /// <summary>
-        /// Gets or Sets Priority
+        ///     Gets or Sets Priority
         /// </summary>
         [DataMember(Name = "priority", EmitDefaultValue = false)]
         public int? Priority { get; set; }
 
         /// <summary>
-        /// Gets or Sets TaskToDomain
+        ///     Gets or Sets TaskToDomain
         /// </summary>
         [DataMember(Name = "taskToDomain", EmitDefaultValue = false)]
         public Dictionary<string, string> TaskToDomain { get; set; }
 
         /// <summary>
-        /// Gets or Sets Version
+        ///     Gets or Sets Version
         /// </summary>
         [DataMember(Name = "version", EmitDefaultValue = false)]
         public int? Version { get; set; }
 
         /// <summary>
-        /// Gets or Sets WorkflowDef
+        ///     Gets or Sets WorkflowDef
         /// </summary>
         [DataMember(Name = "workflowDef", EmitDefaultValue = false)]
         public WorkflowDef WorkflowDef { get; set; }
 
         /// <summary>
-        /// Returns the string presentation of the object
+        ///     Returns true if StartWorkflowRequest instances are equal
+        /// </summary>
+        /// <param name="input">Instance of StartWorkflowRequest to be compared</param>
+        /// <returns>Boolean</returns>
+        public bool Equals(StartWorkflowRequest input)
+        {
+            if (input == null)
+                return false;
+
+            return
+                (
+                    CorrelationId == input.CorrelationId ||
+                    (CorrelationId != null &&
+                     CorrelationId.Equals(input.CorrelationId))
+                ) &&
+                (
+                    CreatedBy == input.CreatedBy ||
+                    (CreatedBy != null &&
+                     CreatedBy.Equals(input.CreatedBy))
+                ) &&
+                (
+                    ExternalInputPayloadStoragePath == input.ExternalInputPayloadStoragePath ||
+                    (ExternalInputPayloadStoragePath != null &&
+                     ExternalInputPayloadStoragePath.Equals(input.ExternalInputPayloadStoragePath))
+                ) &&
+                (
+                    Input == input.Input ||
+                    (Input != null &&
+                     input.Input != null &&
+                     Input.SequenceEqual(input.Input))
+                ) &&
+                (
+                    Name == input.Name ||
+                    (Name != null &&
+                     Name.Equals(input.Name))
+                ) &&
+                (
+                    Priority == input.Priority ||
+                    (Priority != null &&
+                     Priority.Equals(input.Priority))
+                ) &&
+                (
+                    TaskToDomain == input.TaskToDomain ||
+                    (TaskToDomain != null &&
+                     input.TaskToDomain != null &&
+                     TaskToDomain.SequenceEqual(input.TaskToDomain))
+                ) &&
+                (
+                    Version == input.Version ||
+                    (Version != null &&
+                     Version.Equals(input.Version))
+                ) &&
+                (
+                    WorkflowDef == input.WorkflowDef ||
+                    (WorkflowDef != null &&
+                     WorkflowDef.Equals(input.WorkflowDef))
+                );
+        }
+
+        /// <summary>
+        ///     To validate all properties of the instance
+        /// </summary>
+        /// <param name="validationContext">Validation context</param>
+        /// <returns>Validation Result</returns>
+        IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
+        {
+            yield break;
+        }
+
+        /// <summary>
+        ///     Returns the string presentation of the object
         /// </summary>
         /// <returns>String presentation of the object</returns>
         public override string ToString()
@@ -124,7 +198,7 @@ public override string ToString()
         }
 
         /// <summary>
-        /// Returns the JSON string presentation of the object
+        ///     Returns the JSON string presentation of the object
         /// </summary>
         /// <returns>JSON string presentation of the object</returns>
         public virtual string ToJson()
@@ -133,114 +207,44 @@ public virtual string ToJson()
         }
 
         /// <summary>
-        /// Returns true if objects are equal
+        ///     Returns true if objects are equal
         /// </summary>
         /// <param name="input">Object to be compared</param>
         /// <returns>Boolean</returns>
         public override bool Equals(object input)
         {
-            return this.Equals(input as StartWorkflowRequest);
-        }
-
-        /// <summary>
-        /// Returns true if StartWorkflowRequest instances are equal
-        /// </summary>
-        /// <param name="input">Instance of StartWorkflowRequest to be compared</param>
-        /// <returns>Boolean</returns>
-        public bool Equals(StartWorkflowRequest input)
-        {
-            if (input == null)
-                return false;
-
-            return
-                (
-                    this.CorrelationId == input.CorrelationId ||
-                    (this.CorrelationId != null &&
-                    this.CorrelationId.Equals(input.CorrelationId))
-                ) &&
-                (
-                    this.CreatedBy == input.CreatedBy ||
-                    (this.CreatedBy != null &&
-                    this.CreatedBy.Equals(input.CreatedBy))
-                ) &&
-                (
-                    this.ExternalInputPayloadStoragePath == input.ExternalInputPayloadStoragePath ||
-                    (this.ExternalInputPayloadStoragePath != null &&
-                    this.ExternalInputPayloadStoragePath.Equals(input.ExternalInputPayloadStoragePath))
-                ) &&
-                (
-                    this.Input == input.Input ||
-                    this.Input != null &&
-                    input.Input != null &&
-                    this.Input.SequenceEqual(input.Input)
-                ) &&
-                (
-                    this.Name == input.Name ||
-                    (this.Name != null &&
-                    this.Name.Equals(input.Name))
-                ) &&
-                (
-                    this.Priority == input.Priority ||
-                    (this.Priority != null &&
-                    this.Priority.Equals(input.Priority))
-                ) &&
-                (
-                    this.TaskToDomain == input.TaskToDomain ||
-                    this.TaskToDomain != null &&
-                    input.TaskToDomain != null &&
-                    this.TaskToDomain.SequenceEqual(input.TaskToDomain)
-                ) &&
-                (
-                    this.Version == input.Version ||
-                    (this.Version != null &&
-                    this.Version.Equals(input.Version))
-                ) &&
-                (
-                    this.WorkflowDef == input.WorkflowDef ||
-                    (this.WorkflowDef != null &&
-                    this.WorkflowDef.Equals(input.WorkflowDef))
-                );
+            return Equals(input as StartWorkflowRequest);
         }
 
         /// <summary>
-        /// Gets the hash code
+        ///     Gets the hash code
         /// </summary>
         /// <returns>Hash code</returns>
         public override int GetHashCode()
         {
             unchecked // Overflow is fine, just wrap
             {
-                int hashCode = 41;
-                if (this.CorrelationId != null)
-                    hashCode = hashCode * 59 + this.CorrelationId.GetHashCode();
-                if (this.CreatedBy != null)
-                    hashCode = hashCode * 59 + this.CreatedBy.GetHashCode();
-                if (this.ExternalInputPayloadStoragePath != null)
-                    hashCode = hashCode * 59 + this.ExternalInputPayloadStoragePath.GetHashCode();
-                if (this.Input != null)
-                    hashCode = hashCode * 59 + this.Input.GetHashCode();
-                if (this.Name != null)
-                    hashCode = hashCode * 59 + this.Name.GetHashCode();
-                if (this.Priority != null)
-                    hashCode = hashCode * 59 + this.Priority.GetHashCode();
-                if (this.TaskToDomain != null)
-                    hashCode = hashCode * 59 + this.TaskToDomain.GetHashCode();
-                if (this.Version != null)
-                    hashCode = hashCode * 59 + this.Version.GetHashCode();
-                if (this.WorkflowDef != null)
-                    hashCode = hashCode * 59 + this.WorkflowDef.GetHashCode();
+                var hashCode = 41;
+                if (CorrelationId != null)
+                    hashCode = hashCode * 59 + CorrelationId.GetHashCode();
+                if (CreatedBy != null)
+                    hashCode = hashCode * 59 + CreatedBy.GetHashCode();
+                if (ExternalInputPayloadStoragePath != null)
+                    hashCode = hashCode * 59 + ExternalInputPayloadStoragePath.GetHashCode();
+                if (Input != null)
+                    hashCode = hashCode * 59 + Input.GetHashCode();
+                if (Name != null)
+                    hashCode = hashCode * 59 + Name.GetHashCode();
+                if (Priority != null)
+                    hashCode = hashCode * 59 + Priority.GetHashCode();
+                if (TaskToDomain != null)
+                    hashCode = hashCode * 59 + TaskToDomain.GetHashCode();
+                if (Version != null)
+                    hashCode = hashCode * 59 + Version.GetHashCode();
+                if (WorkflowDef != null)
+                    hashCode = hashCode * 59 + WorkflowDef.GetHashCode();
                 return hashCode;
             }
         }
-
-        /// <summary>
-        /// To validate all properties of the instance
-        /// </summary>
-        /// <param name="validationContext">Validation context</param>
-        /// <returns>Validation Result</returns>
-        IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
-        {
-            yield break;
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/Conductor/Client/Models/TaskDef.cs b/Conductor/Client/Models/TaskDef.cs
index 789c15e..186a1ff 100644
--- a/Conductor/Client/Models/TaskDef.cs
+++ b/Conductor/Client/Models/TaskDef.cs
@@ -99,24 +99,8 @@ public enum TimeoutPolicyEnum
         /// <param name="updatedBy">updatedBy.</param>
         public TaskDef(int? backoffScaleFactor = default(int?), int? concurrentExecLimit = default(int?), long? createTime = default(long?), string createdBy = default(string), string description = default(string), string executionNameSpace = default(string), List<string> inputKeys = default(List<string>), Dictionary<string, Object> inputTemplate = default(Dictionary<string, Object>), string isolationGroupId = default(string), string name = default(string), List<string> outputKeys = default(List<string>), string ownerApp = default(string), string ownerEmail = default(string), int? pollTimeoutSeconds = default(int?), int? rateLimitFrequencyInSeconds = default(int?), int? rateLimitPerFrequency = default(int?), long? responseTimeoutSeconds = default(long?), int? retryCount = default(int?), int? retryDelaySeconds = default(int?), RetryLogicEnum? retryLogic = default(RetryLogicEnum?), TimeoutPolicyEnum? timeoutPolicy = default(TimeoutPolicyEnum?), long? timeoutSeconds = default(long?), long? updateTime = default(long?), string updatedBy = default(string))
         {
-            // to ensure "name" is required (not null)
-            if (name == null)
-            {
-                throw new InvalidDataException("name is a required property for TaskDef and cannot be null");
-            }
-            else
-            {
-                this.Name = name;
-            }
-            // to ensure "timeoutSeconds" is required (not null)
-            if (timeoutSeconds == null)
-            {
-                throw new InvalidDataException("timeoutSeconds is a required property for TaskDef and cannot be null");
-            }
-            else
-            {
-                this.TimeoutSeconds = timeoutSeconds;
-            }
+            this.Name = name;
+            this.TimeoutSeconds = timeoutSeconds;
             this.BackoffScaleFactor = backoffScaleFactor;
             this.ConcurrentExecLimit = concurrentExecLimit;
             this.CreateTime = createTime;
diff --git a/Conductor/Client/Models/TaskResult.cs b/Conductor/Client/Models/TaskResult.cs
index 38acbcd..9eb10c1 100644
--- a/Conductor/Client/Models/TaskResult.cs
+++ b/Conductor/Client/Models/TaskResult.cs
@@ -63,24 +63,8 @@ public enum StatusEnum
         /// <param name="workflowInstanceId">workflowInstanceId (required).</param>
         public TaskResult(long? callbackAfterSeconds = default(long?), string externalOutputPayloadStoragePath = default(string), List<TaskExecLog> logs = default(List<TaskExecLog>), Dictionary<string, Object> outputData = default(Dictionary<string, Object>), string reasonForIncompletion = default(string), StatusEnum? status = default(StatusEnum?), string subWorkflowId = default(string), string taskId = default(string), string workerId = default(string), string workflowInstanceId = default(string))
         {
-            // to ensure "taskId" is required (not null)
-            if (taskId == null)
-            {
-                throw new InvalidDataException("taskId is a required property for TaskResult and cannot be null");
-            }
-            else
-            {
-                this.TaskId = taskId;
-            }
-            // to ensure "workflowInstanceId" is required (not null)
-            if (workflowInstanceId == null)
-            {
-                throw new InvalidDataException("workflowInstanceId is a required property for TaskResult and cannot be null");
-            }
-            else
-            {
-                this.WorkflowInstanceId = workflowInstanceId;
-            }
+            this.TaskId = taskId;
+            this.WorkflowInstanceId = workflowInstanceId;
             this.CallbackAfterSeconds = callbackAfterSeconds;
             this.ExternalOutputPayloadStoragePath = externalOutputPayloadStoragePath;
             this.Logs = logs;
diff --git a/Conductor/Client/Models/WorkflowStateUpdate.cs b/Conductor/Client/Models/WorkflowStateUpdate.cs
new file mode 100644
index 0000000..fcb344a
--- /dev/null
+++ b/Conductor/Client/Models/WorkflowStateUpdate.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace Conductor.Client.Models
+{
+    /// <summary>
+    /// WorkflowStateUpdate
+    /// </summary>
+    [DataContract]
+    public partial class WorkflowStateUpdate : IEquatable<WorkflowStateUpdate>, IValidatableObject
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WorkflowStateUpdate" /> class.
+        /// </summary>
+        /// <param name="taskReferenceName">taskReferenceName.</param>
+        /// <param name="taskResult">taskResult.</param>
+        /// <param name="variables">variables.</param>
+        public WorkflowStateUpdate(string taskReferenceName = default(string),
+            TaskResult taskResult = default(TaskResult),
+            Dictionary<string, Object> variables = default(Dictionary<string, Object>))
+        {
+            this.TaskReferenceName = taskReferenceName;
+            this.TaskResult = taskResult;
+            this.Variables = variables;
+        }
+
+        /// <summary>
+        /// Gets or Sets TaskReferenceName
+        /// </summary>
+        [DataMember(Name = "taskReferenceName", EmitDefaultValue = false)]
+        public string TaskReferenceName { get; set; }
+
+        /// <summary>
+        /// Gets or Sets TaskResult
+        /// </summary>
+        [DataMember(Name = "taskResult", EmitDefaultValue = false)]
+        public TaskResult TaskResult { get; set; }
+
+        /// <summary>
+        /// Gets or Sets Variables
+        /// </summary>
+        [DataMember(Name = "variables", EmitDefaultValue = false)]
+        public Dictionary<string, Object> Variables { get; set; }
+
+        /// <summary>
+        /// Returns the string presentation of the object
+        /// </summary>
+        /// <returns>String presentation of the object</returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+            sb.Append("class WorkflowStateUpdate {\n");
+            sb.Append("  TaskReferenceName: ").Append(TaskReferenceName).Append("\n");
+            sb.Append("  TaskResult: ").Append(TaskResult).Append("\n");
+            sb.Append("  Variables: ").Append(Variables).Append("\n");
+            sb.Append("}\n");
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Returns the JSON string presentation of the object
+        /// </summary>
+        /// <returns>JSON string presentation of the object</returns>
+        public virtual string ToJson()
+        {
+            return JsonConvert.SerializeObject(this, Formatting.Indented);
+        }
+
+        /// <summary>
+        /// Returns true if objects are equal
+        /// </summary>
+        /// <param name="input">Object to be compared</param>
+        /// <returns>Boolean</returns>
+        public override bool Equals(object input)
+        {
+            return this.Equals(input as WorkflowStateUpdate);
+        }
+
+        /// <summary>
+        /// Returns true if WorkflowStateUpdate instances are equal
+        /// </summary>
+        /// <param name="input">Instance of WorkflowStateUpdate to be compared</param>
+        /// <returns>Boolean</returns>
+        public bool Equals(WorkflowStateUpdate input)
+        {
+            if (input == null)
+                return false;
+
+            return
+                (
+                    this.TaskReferenceName == input.TaskReferenceName ||
+                    (this.TaskReferenceName != null &&
+                     this.TaskReferenceName.Equals(input.TaskReferenceName))
+                ) &&
+                (
+                    this.TaskResult == input.TaskResult ||
+                    (this.TaskResult != null &&
+                     this.TaskResult.Equals(input.TaskResult))
+                ) &&
+                (
+                    this.Variables == input.Variables ||
+                    this.Variables != null &&
+                    input.Variables != null &&
+                    this.Variables.SequenceEqual(input.Variables)
+                );
+        }
+
+        /// <summary>
+        /// Gets the hash code
+        /// </summary>
+        /// <returns>Hash code</returns>
+        public override int GetHashCode()
+        {
+            unchecked // Overflow is fine, just wrap
+            {
+                int hashCode = 41;
+                if (this.TaskReferenceName != null)
+                    hashCode = hashCode * 59 + this.TaskReferenceName.GetHashCode();
+                if (this.TaskResult != null)
+                    hashCode = hashCode * 59 + this.TaskResult.GetHashCode();
+                if (this.Variables != null)
+                    hashCode = hashCode * 59 + this.Variables.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// To validate all properties of the instance
+        /// </summary>
+        /// <param name="validationContext">Validation context</param>
+        /// <returns>Validation Result</returns>
+        IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(
+            ValidationContext validationContext)
+        {
+            yield break;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tests/Api/WorkflowResourceApiTest.cs b/Tests/Api/WorkflowResourceApiTest.cs
index be9fb62..97ffb35 100644
--- a/Tests/Api/WorkflowResourceApiTest.cs
+++ b/Tests/Api/WorkflowResourceApiTest.cs
@@ -1,3 +1,4 @@
+using System;
 using conductor.csharp.Client.Extensions;
 using Conductor.Api;
 using Conductor.Client.Extensions;
@@ -6,8 +7,12 @@
 using Conductor.Definition.TaskType;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
+using System.Linq;
+using conductor_csharp.Api;
 using Tests.Worker;
 using Xunit;
+using Xunit.Abstractions;
+using Task = Conductor.Client.Models.Task;
 
 namespace conductor_csharp.test.Api
 {
@@ -22,14 +27,19 @@ public class WorkflowResourceApiTest
         private const string OWNER_EMAIL = "developer@orkes.io";
         
         private readonly WorkflowResourceApi _workflowClient;
+        private readonly ITaskResourceApi _taskClient;
         private readonly MetadataResourceApi _metadataResourceApi;
         private readonly ILogger _logger;
+        private readonly ITestOutputHelper _testOutputHelper;
 
-        public WorkflowResourceApiTest()
+
+        public WorkflowResourceApiTest(ITestOutputHelper testOutputHelper)
         {
             _workflowClient = ApiExtensions.GetClient<WorkflowResourceApi>();
+            _taskClient = ApiExtensions.GetClient<TaskResourceApi>();
             _metadataResourceApi = ApiExtensions.GetClient<MetadataResourceApi>();
             _logger = ApplicationLogging.CreateLogger<WorkerTests>();
+            _testOutputHelper = testOutputHelper;
         }
 
         [Fact]
@@ -105,11 +115,10 @@ public async void UpdateWorkflowVariables()
                       {WORKFLOW_VARIABLE_1,"Value1" },
                       {WORKFLOW_VARIABLE_2,"Value2" },
                   };
-            var updateVariableData = new Workflow() { WorkflowId = workflowId, Variables = updateDict };
+            
             // Update the work flow variables 
-            _workflowClient.UpdateWorkflowVariables(updateVariableData);
-            // Fetch latest workflow data to validate the change in variables
-            var _updatedWorkFlow = _workflowClient.GetWorkflowStatusSummary(workflowId, includeVariables: true);
+            var _updatedWorkFlow = _workflowClient.UpdateWorkflowVariables(workflowId, updateDict);
+            
             // Verify workflow variables data is equal with input passed 
             Assert.Equal(_updatedWorkFlow.Variables, updateDict);
 
@@ -147,17 +156,141 @@ private void DeleteWorkflowExecution(string workflowId)
             Assert.DoesNotContain(workflowId, res.Data);
         }
 
-        //[Fact]
-        //public void DeleteAllWorkflowExecution()
-        //{
+        [Fact]
+    public void TestWorkflowOperations()
+    {
+        // Start Workflow
+        var correlationId = Guid.NewGuid().ToString();
+        var startWorkflowRequest = new StartWorkflowRequest
+        {
+            Name = "csharp_sync_task_variable_updates",
+            Version = 1,
+            Input = new Dictionary<string, object>(),
+            CorrelationId = correlationId
+        };
+        var workflowId = _workflowClient.StartWorkflow(startWorkflowRequest);
+        _testOutputHelper.WriteLine($"Started workflow with id {workflowId}");
+
+        // Update a variable inside the workflow 
+        _workflowClient.UpdateWorkflowVariables(workflowId, new Dictionary<string, object> { { "case", "case1" } });
+
+        // Get workflow execution status
+        var workflow = _workflowClient.GetWorkflow(workflowId, true);
+        var lastTask = workflow.Tasks.Last();
+        _testOutputHelper.WriteLine(
+            $"Workflow status is {workflow.Status} and currently running task is {lastTask.ReferenceTaskName}");
+
+        workflow = _taskClient.UpdateTaskSync(new Dictionary<string, object> { { "a", "b" } }, workflowId,
+            lastTask.ReferenceTaskName, TaskResult.StatusEnum.COMPLETED, "test_worker");
+
+        // Get updated workflow status
+        lastTask = workflow.Tasks.Last();
+        Assert.Equal(lastTask.Status, Task.StatusEnum.INPROGRESS);
+        _testOutputHelper.WriteLine(
+            $"Workflow status is {workflow.Status} and currently running task is {lastTask.ReferenceTaskName}");
+
+        // Terminate the workflow
+        _workflowClient.Terminate(workflowId, "testing termination");
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.TERMINATED, workflow.Status);
+        lastTask = workflow.Tasks.Last();
+        _testOutputHelper.WriteLine(
+            $"Workflow status is {workflow.Status} and status of last task {lastTask.Status}");
+
+        // Retry the workflow
+        _workflowClient.Retry(workflowId);
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.RUNNING, workflow.Status);
+        lastTask = workflow.Tasks.Last();
+        _testOutputHelper.WriteLine(
+            $"Workflow status is {workflow.Status} and status of last task {lastTask.ReferenceTaskName} is {lastTask.Status}");
+
+        // Mark the WAIT task as completed by calling Task completion API
+        var taskResult = new TaskResult
+        {
+            WorkflowInstanceId = workflowId,
+            TaskId = lastTask.TaskId,
+            Status = TaskResult.StatusEnum.COMPLETED,
+            OutputData = new Dictionary<string, object> { { "greetings", "hello from Orkes" } }
+        };
+        workflow = _taskClient.UpdateTaskSync(
+            new Dictionary<string, object> { { "greetings", "hello from Orkes" } },
+            workflowId, lastTask.ReferenceTaskName, TaskResult.StatusEnum.COMPLETED, "");
+
+        lastTask = workflow.Tasks.Last();
+        Assert.Equal(Task.StatusEnum.SCHEDULED, lastTask.Status);
+        _testOutputHelper.WriteLine(
+            $"Workflow status is {workflow.Status} and status of last task {lastTask.ReferenceTaskName} is {lastTask.Status}");
 
-        //    var res = _workflowClient.GetRunningWorkflowWithHttpInfo(WORKFLOW_NAME);
+        // Terminate the workflow again
+        _workflowClient.Terminate(workflowId, "terminating for testing");
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.TERMINATED, workflow.Status);
 
-        //    res.Data.ForEach(x => _workflowClient.Delete(x));
 
-        //    res = _workflowClient.GetRunningWorkflowWithHttpInfo(WORKFLOW_NAME);
+        // Rerun workflow from a specific task
+        var rerunRequest = new RerunWorkflowRequest
+        {
+            ReRunFromTaskId = workflow.Tasks[3].TaskId
+        };
+        _workflowClient.Rerun(rerunRequest, workflowId);
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.RUNNING, workflow.Status);
+
+
+        // Restart the workflow
+        _workflowClient.Terminate(workflowId, "terminating so we can do a restart");
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.TERMINATED, workflow.Status);
+
+        _workflowClient.Restart(workflowId);
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.RUNNING, workflow.Status);
+
+        // Pause the workflow
+        _workflowClient.PauseWorkflow(workflowId);
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        Assert.Equal(Workflow.StatusEnum.PAUSED, workflow.Status);
+        _testOutputHelper.WriteLine($"Workflow status is {workflow.Status}");
+
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+        // Wait task should have completed
+        var waitTask = workflow.Tasks[0];
+        Assert.Equal(Task.StatusEnum.INPROGRESS, waitTask.Status);
+        _testOutputHelper.WriteLine($"Workflow status is {workflow.Status} and wait task is {waitTask.Status}");
+
 
-        //    Assert.Equal(0, res.Data.Count);
-        //}
+        // Because workflow is paused, no further task should have been scheduled, making WAIT the last task
+        // Expecting only 1 task
+        _testOutputHelper.WriteLine($"Number of tasks in workflow is {workflow.Tasks.Count}");
+        Assert.Single(workflow.Tasks);
+
+        // Resume the workflow
+        _workflowClient.ResumeWorkflow(workflowId);
+        lastTask = workflow.Tasks.Last();
+        workflow = _taskClient.UpdateTaskSync(new Dictionary<string, object> { { "a", "b" } }, workflowId,
+            lastTask.ReferenceTaskName, TaskResult.StatusEnum.COMPLETED, "test_worker");
+
+        workflow = _workflowClient.GetWorkflow(workflowId, true);
+
+        // There should be 3 tasks
+        _testOutputHelper.WriteLine(
+            $"Number of tasks in workflow is {workflow.Tasks.Count} and last task is {workflow.Tasks.Last().ReferenceTaskName}");
+        Assert.Equal(3, workflow.Tasks.Count);
+
+        // Search for workflows
+        var searchResults = _workflowClient.Search(start: 0, size: 100, freeText: "*",
+            query: $"correlationId = '{correlationId}'");
+        _testOutputHelper.WriteLine(
+            $"Found {searchResults.Results.Count} execution with correlation_id '{correlationId}'");
+        Assert.Single(searchResults.Results);
+
+        correlationId = Guid.NewGuid().ToString();
+        searchResults = _workflowClient.Search(start: 0, size: 100, freeText: "*",
+            query: $"status IN (RUNNING) AND correlationId = \"{correlationId}\"");
+        // Shouldn't find anything!
+        _testOutputHelper.WriteLine(
+            $"Found {searchResults.Results.Count} workflows with correlation id {correlationId}");
+    }
     }
 }
diff --git a/csharp-examples/WorkFlowExamples.cs b/csharp-examples/WorkFlowExamples.cs
index eceb93a..8f34dc5 100644
--- a/csharp-examples/WorkFlowExamples.cs
+++ b/csharp-examples/WorkFlowExamples.cs
@@ -69,11 +69,7 @@ public void TestUpdateWorkflowVariablesWithWorkFlowId()
                 { VARIABLE_NAME_2, VARIABLE_NEW_VALUE_2 }
             };
 
-            workflowClient.UpdateWorkflowVariables(new Conductor.Client.Models.Workflow()
-            {
-                WorkflowId = WORKFLOW_ID,
-                Variables = workFlowVariables
-            });
+            workflowClient.UpdateWorkflowVariables(WORKFLOW_ID, workFlowVariables);
         }
 
         /// <summary>