# Orchestrator plugin

## API and SDK Documentation

Version: 0.0.1

API to interact with orchestrator plugin

# Default

# abortWorkflow

Abort a workflow instance

Aborts a workflow instance identified by the provided instanceId.

    /v2/workflows/instances/{instanceId}/abort

### Usage and SDK Samples

    curl -X DELETE \
     -H "Accept: text/plain,application/json" \
     "http://localhost/v2/workflows/instances/{instanceId}/abort"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

            try {
                'String' result = apiInstance.abortWorkflow(instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#abortWorkflow");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String instanceId = new String(); // String | The identifier of the workflow instance to abort.

    try {
        final result = await api_instance.abortWorkflow(instanceId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->abortWorkflow: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

            try {
                'String' result = apiInstance.abortWorkflow(instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#abortWorkflow");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *instanceId = instanceId_example; // The identifier of the workflow instance to abort. (default to null)

    // Abort a workflow instance
    [apiInstance abortWorkflowWith:instanceId
                  completionHandler: ^('String' output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var instanceId = instanceId_example; // {String} The identifier of the workflow instance to abort.

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.abortWorkflow(instanceId, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class abortWorkflowExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var instanceId = instanceId_example;  // String | The identifier of the workflow instance to abort. (default to null)

                try {
                    // Abort a workflow instance
                    'String' result = apiInstance.abortWorkflow(instanceId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.abortWorkflow: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

    try {
        $result = $api_instance->abortWorkflow($instanceId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->abortWorkflow: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $instanceId = instanceId_example; # String | The identifier of the workflow instance to abort.

    eval {
        my $result = $api_instance->abortWorkflow(instanceId => $instanceId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->abortWorkflow: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    instanceId = instanceId_example # String | The identifier of the workflow instance to abort. (default to null)

    try:
        # Abort a workflow instance
        api_response = api_instance.abort_workflow(instanceId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->abortWorkflow: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let instanceId = instanceId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.abortWorkflow(instanceId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
instanceId* | String The identifier of the workflow instance to abort. Required

## Responses

###

###

# executeWorkflow

Execute a workflow

Execute a workflow

    /v2/workflows/{workflowId}/execute

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/{workflowId}/execute" \
     -d '{
      "inputData" : "{}",
      "authTokens" : [ {
        "provider" : "provider",
        "token" : "token"
      }, {
        "provider" : "provider",
        "token" : "token"
      } ],
      "targetEntity" : "targetEntity"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to execute
            ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO |

            try {
                ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#executeWorkflow");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow to execute
    final ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = new ExecuteWorkflowRequestDTO(); // ExecuteWorkflowRequestDTO |

    try {
        final result = await api_instance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->executeWorkflow: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to execute
            ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO |

            try {
                ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#executeWorkflow");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow to execute (default to null)
    ExecuteWorkflowRequestDTO *executeWorkflowRequestDTO = ; //

    // Execute a workflow
    [apiInstance executeWorkflowWith:workflowId
        executeWorkflowRequestDTO:executeWorkflowRequestDTO
                  completionHandler: ^(ExecuteWorkflowResponseDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow to execute
    var executeWorkflowRequestDTO = ; // {ExecuteWorkflowRequestDTO}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.executeWorkflow(workflowId, executeWorkflowRequestDTO, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class executeWorkflowExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow to execute (default to null)
                var executeWorkflowRequestDTO = new ExecuteWorkflowRequestDTO(); // ExecuteWorkflowRequestDTO |

                try {
                    // Execute a workflow
                    ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.executeWorkflow: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow to execute
    $executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO |

    try {
        $result = $api_instance->executeWorkflow($workflowId, $executeWorkflowRequestDTO);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->executeWorkflow: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow to execute
    my $executeWorkflowRequestDTO = WWW::OPenAPIClient::Object::ExecuteWorkflowRequestDTO->new(); # ExecuteWorkflowRequestDTO |

    eval {
        my $result = $api_instance->executeWorkflow(workflowId => $workflowId, executeWorkflowRequestDTO => $executeWorkflowRequestDTO);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->executeWorkflow: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow to execute (default to null)
    executeWorkflowRequestDTO =  # ExecuteWorkflowRequestDTO |

    try:
        # Execute a workflow
        api_response = api_instance.execute_workflow(workflowId, executeWorkflowRequestDTO)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->executeWorkflow: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String
        let executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO

        let mut context = DefaultApi::Context::default();
        let result = client.executeWorkflow(workflowId, executeWorkflowRequestDTO, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow to execute Required

Body parameters

Name | Description
--- | ---
executeWorkflowRequestDTO * |

## Responses

###

###

# getInstanceById

Get Workflow Instance by ID

Get a workflow execution/run (instance)

    /v2/workflows/instances/{instanceId}

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/v2/workflows/instances/{instanceId}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String instanceId = instanceId_example; // String | ID of the workflow instance

            try {
                ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getInstanceById");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String instanceId = new String(); // String | ID of the workflow instance

    try {
        final result = await api_instance.getInstanceById(instanceId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getInstanceById: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String instanceId = instanceId_example; // String | ID of the workflow instance

            try {
                ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getInstanceById");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *instanceId = instanceId_example; // ID of the workflow instance (default to null)

    // Get Workflow Instance by ID
    [apiInstance getInstanceByIdWith:instanceId
                  completionHandler: ^(ProcessInstanceDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var instanceId = instanceId_example; // {String} ID of the workflow instance

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getInstanceById(instanceId, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getInstanceByIdExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var instanceId = instanceId_example;  // String | ID of the workflow instance (default to null)

                try {
                    // Get Workflow Instance by ID
                    ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getInstanceById: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $instanceId = instanceId_example; // String | ID of the workflow instance

    try {
        $result = $api_instance->getInstanceById($instanceId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getInstanceById: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $instanceId = instanceId_example; # String | ID of the workflow instance

    eval {
        my $result = $api_instance->getInstanceById(instanceId => $instanceId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getInstanceById: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    instanceId = instanceId_example # String | ID of the workflow instance (default to null)

    try:
        # Get Workflow Instance by ID
        api_response = api_instance.get_instance_by_id(instanceId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getInstanceById: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let instanceId = instanceId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getInstanceById(instanceId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
instanceId* | String ID of the workflow instance Required

## Responses

###

###

# getInstances

Get instances

Retrieve an array of workflow executions (instances)

    /v2/workflows/instances

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/instances" \
     -d '{
      "paginationInfo" : {
        "offset" : 1.4658129805029452,
        "pageSize" : 6.027456183070403,
        "orderDirection" : "ASC",
        "orderBy" : "orderBy"
      },
      "filters" : {
        "filters" : [ null, null ],
        "operator" : "AND"
      }
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getInstances");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final SearchRequest searchRequest = new SearchRequest(); // SearchRequest |

    try {
        final result = await api_instance.getInstances(searchRequest);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getInstances: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getInstances");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    SearchRequest *searchRequest = ; //  (optional)

    // Get instances
    [apiInstance getInstancesWith:searchRequest
                  completionHandler: ^(ProcessInstanceListResultDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var opts = {
      'searchRequest':  // {SearchRequest}
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getInstances(opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getInstancesExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var searchRequest = new SearchRequest(); // SearchRequest |  (optional)

                try {
                    // Get instances
                    ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getInstances: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $searchRequest = ; // SearchRequest |

    try {
        $result = $api_instance->getInstances($searchRequest);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getInstances: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest |

    eval {
        my $result = $api_instance->getInstances(searchRequest => $searchRequest);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getInstances: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    searchRequest =  # SearchRequest |  (optional)

    try:
        # Get instances
        api_response = api_instance.get_instances(searchRequest=searchRequest)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getInstances: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let searchRequest = ; // SearchRequest

        let mut context = DefaultApi::Context::default();
        let result = client.getInstances(searchRequest, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
searchRequest | Parameters for retrieving instances

## Responses

###

###

# getWorkflowInputSchemaById

Get the workflow input schema. It defines the input fields of the workflow

    /v2/workflows/{workflowId}/inputSchema

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/v2/workflows/{workflowId}/inputSchema?instanceId=instanceId_example"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch
            String instanceId = instanceId_example; // String | ID of instance

            try {
                InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowInputSchemaById");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow to fetch
    final String instanceId = new String(); // String | ID of instance

    try {
        final result = await api_instance.getWorkflowInputSchemaById(workflowId, instanceId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowInputSchemaById: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch
            String instanceId = instanceId_example; // String | ID of instance

            try {
                InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowInputSchemaById");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)
    String *instanceId = instanceId_example; // ID of instance (optional) (default to null)

    [apiInstance getWorkflowInputSchemaByIdWith:workflowId
        instanceId:instanceId
                  completionHandler: ^(InputSchemaResponseDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow to fetch
    var opts = {
      'instanceId': instanceId_example // {String} ID of instance
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowInputSchemaById(workflowId, opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowInputSchemaByIdExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)
                var instanceId = instanceId_example;  // String | ID of instance (optional)  (default to null)

                try {
                    InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowInputSchemaById: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow to fetch
    $instanceId = instanceId_example; // String | ID of instance

    try {
        $result = $api_instance->getWorkflowInputSchemaById($workflowId, $instanceId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowInputSchemaById: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow to fetch
    my $instanceId = instanceId_example; # String | ID of instance

    eval {
        my $result = $api_instance->getWorkflowInputSchemaById(workflowId => $workflowId, instanceId => $instanceId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowInputSchemaById: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)
    instanceId = instanceId_example # String | ID of instance (optional) (default to null)

    try:
        api_response = api_instance.get_workflow_input_schema_by_id(workflowId, instanceId=instanceId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowInputSchemaById: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String
        let instanceId = instanceId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowInputSchemaById(workflowId, instanceId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow to fetch Required

Query parameters

Name | Description
--- | ---
instanceId | String ID of instance

## Responses

###

###

# getWorkflowInstances

Get instances for a specific workflow

Retrieve an array of workflow executions (instances) for the given workflow

    /v2/workflows/{workflowId}/instances

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/{workflowId}/instances" \
     -d '{
      "paginationInfo" : {
        "offset" : 1.4658129805029452,
        "pageSize" : 6.027456183070403,
        "orderDirection" : "ASC",
        "orderBy" : "orderBy"
      },
      "filters" : {
        "filters" : [ null, null ],
        "operator" : "AND"
      }
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowInstances");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow
    final SearchRequest searchRequest = new SearchRequest(); // SearchRequest |

    try {
        final result = await api_instance.getWorkflowInstances(workflowId, searchRequest);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowInstances: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowInstances");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow (default to null)
    SearchRequest *searchRequest = ; //  (optional)

    // Get instances for a specific workflow
    [apiInstance getWorkflowInstancesWith:workflowId
        searchRequest:searchRequest
                  completionHandler: ^(ProcessInstanceListResultDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow
    var opts = {
      'searchRequest':  // {SearchRequest}
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowInstances(workflowId, opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowInstancesExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow (default to null)
                var searchRequest = new SearchRequest(); // SearchRequest |  (optional)

                try {
                    // Get instances for a specific workflow
                    ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowInstances: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow
    $searchRequest = ; // SearchRequest |

    try {
        $result = $api_instance->getWorkflowInstances($workflowId, $searchRequest);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowInstances: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow
    my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest |

    eval {
        my $result = $api_instance->getWorkflowInstances(workflowId => $workflowId, searchRequest => $searchRequest);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowInstances: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow (default to null)
    searchRequest =  # SearchRequest |  (optional)

    try:
        # Get instances for a specific workflow
        api_response = api_instance.get_workflow_instances(workflowId, searchRequest=searchRequest)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowInstances: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String
        let searchRequest = ; // SearchRequest

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowInstances(workflowId, searchRequest, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow Required

Body parameters

Name | Description
--- | ---
searchRequest | Parameters for retrieving workflow instances

## Responses

###

###

# getWorkflowOverviewById

Returns the key fields of the workflow including data on the last run instance

    /v2/workflows/{workflowId}/overview

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/v2/workflows/{workflowId}/overview"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | Unique identifier of the workflow

            try {
                WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowOverviewById");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | Unique identifier of the workflow

    try {
        final result = await api_instance.getWorkflowOverviewById(workflowId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowOverviewById: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | Unique identifier of the workflow

            try {
                WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowOverviewById");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // Unique identifier of the workflow (default to null)

    [apiInstance getWorkflowOverviewByIdWith:workflowId
                  completionHandler: ^(WorkflowOverviewDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} Unique identifier of the workflow

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowOverviewById(workflowId, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowOverviewByIdExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | Unique identifier of the workflow (default to null)

                try {
                    WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowOverviewById: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | Unique identifier of the workflow

    try {
        $result = $api_instance->getWorkflowOverviewById($workflowId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowOverviewById: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | Unique identifier of the workflow

    eval {
        my $result = $api_instance->getWorkflowOverviewById(workflowId => $workflowId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowOverviewById: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | Unique identifier of the workflow (default to null)

    try:
        api_response = api_instance.get_workflow_overview_by_id(workflowId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowOverviewById: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowOverviewById(workflowId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String Unique identifier of the workflow Required

## Responses

###

###

# getWorkflowSourceById

Get the workflow's definition

    /v2/workflows/{workflowId}/source

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: text/plain,application/json" \
     "http://localhost/v2/workflows/{workflowId}/source"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch

            try {
                'String' result = apiInstance.getWorkflowSourceById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowSourceById");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow to fetch

    try {
        final result = await api_instance.getWorkflowSourceById(workflowId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowSourceById: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch

            try {
                'String' result = apiInstance.getWorkflowSourceById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowSourceById");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)

    [apiInstance getWorkflowSourceByIdWith:workflowId
                  completionHandler: ^('String' output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow to fetch

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowSourceById(workflowId, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowSourceByIdExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)

                try {
                    'String' result = apiInstance.getWorkflowSourceById(workflowId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowSourceById: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow to fetch

    try {
        $result = $api_instance->getWorkflowSourceById($workflowId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowSourceById: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow to fetch

    eval {
        my $result = $api_instance->getWorkflowSourceById(workflowId => $workflowId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowSourceById: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)

    try:
        api_response = api_instance.get_workflow_source_by_id(workflowId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowSourceById: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowSourceById(workflowId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow to fetch Required

## Responses

###

###

# getWorkflowStatuses

Get workflow status list

Retrieve array with the status of all instances

    /v2/workflows/instances/statuses

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/v2/workflows/instances/statuses"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowStatuses");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    try {
        final result = await api_instance.getWorkflowStatuses();
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowStatuses: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowStatuses");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    // Get workflow status list
    [apiInstance getWorkflowStatusesWithCompletionHandler:
                  ^(array[WorkflowRunStatusDTO] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowStatuses(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowStatusesExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    // Get workflow status list
                    array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowStatuses: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $result = $api_instance->getWorkflowStatuses();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowStatuses: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        my $result = $api_instance->getWorkflowStatuses();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowStatuses: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        # Get workflow status list
        api_response = api_instance.get_workflow_statuses()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowStatuses: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowStatuses(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# getWorkflowsOverview

Returns the key fields of the workflow including data on the last run instance

    /v2/workflows/overview

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/overview" \
     -d '{
      "paginationInfo" : {
        "offset" : 1.4658129805029452,
        "pageSize" : 6.027456183070403,
        "orderDirection" : "ASC",
        "orderBy" : "orderBy"
      },
      "filters" : {
        "filters" : [ null, null ],
        "operator" : "AND"
      }
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowsOverview");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final SearchRequest searchRequest = new SearchRequest(); // SearchRequest |

    try {
        final result = await api_instance.getWorkflowsOverview(searchRequest);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowsOverview: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            SearchRequest searchRequest = ; // SearchRequest |

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowsOverview");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    SearchRequest *searchRequest = ; //  (optional)

    [apiInstance getWorkflowsOverviewWith:searchRequest
                  completionHandler: ^(WorkflowOverviewListResultDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var opts = {
      'searchRequest':  // {SearchRequest}
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowsOverview(opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowsOverviewExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var searchRequest = new SearchRequest(); // SearchRequest |  (optional)

                try {
                    WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowsOverview: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $searchRequest = ; // SearchRequest |

    try {
        $result = $api_instance->getWorkflowsOverview($searchRequest);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowsOverview: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest |

    eval {
        my $result = $api_instance->getWorkflowsOverview(searchRequest => $searchRequest);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowsOverview: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    searchRequest =  # SearchRequest |  (optional)

    try:
        api_response = api_instance.get_workflows_overview(searchRequest=searchRequest)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowsOverview: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let searchRequest = ; // SearchRequest

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowsOverview(searchRequest, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
searchRequest | Pagination and filters

## Responses

###

###

# getWorkflowsOverviewForEntity

Returns the key fields of the workflow including data on the last run instance

    /v2/workflows/overview/entity

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/overview/entity" \
     -d ''

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest |

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowsOverviewForEntity");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = new GetWorkflowsOverviewForEntityRequest(); // GetWorkflowsOverviewForEntityRequest |

    try {
        final result = await api_instance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->getWorkflowsOverviewForEntity: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest |

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkflowsOverviewForEntity");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    GetWorkflowsOverviewForEntityRequest *getWorkflowsOverviewForEntityRequest = ; //  (optional)

    [apiInstance getWorkflowsOverviewForEntityWith:getWorkflowsOverviewForEntityRequest
                  completionHandler: ^(WorkflowOverviewListResultDTO output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var opts = {
      'getWorkflowsOverviewForEntityRequest':  // {GetWorkflowsOverviewForEntityRequest}
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getWorkflowsOverviewForEntity(opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getWorkflowsOverviewForEntityExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var getWorkflowsOverviewForEntityRequest = new GetWorkflowsOverviewForEntityRequest(); // GetWorkflowsOverviewForEntityRequest |  (optional)

                try {
                    WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkflowsOverviewForEntity: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest |

    try {
        $result = $api_instance->getWorkflowsOverviewForEntity($getWorkflowsOverviewForEntityRequest);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getWorkflowsOverviewForEntity: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $getWorkflowsOverviewForEntityRequest = WWW::OPenAPIClient::Object::GetWorkflowsOverviewForEntityRequest->new(); # GetWorkflowsOverviewForEntityRequest |

    eval {
        my $result = $api_instance->getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest => $getWorkflowsOverviewForEntityRequest);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getWorkflowsOverviewForEntity: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    getWorkflowsOverviewForEntityRequest =  # GetWorkflowsOverviewForEntityRequest |  (optional)

    try:
        api_response = api_instance.get_workflows_overview_for_entity(getWorkflowsOverviewForEntityRequest=getWorkflowsOverviewForEntityRequest)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getWorkflowsOverviewForEntity: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest

        let mut context = DefaultApi::Context::default();
        let result = client.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
getWorkflowsOverviewForEntityRequest | Target entity reference and annotation workflow ids

## Responses

###

###

# pingWorkflowServiceById

Returns true if the workflow service is up for the given workflow ID.

    /v2/workflows/{workflowId}/pingWorkflowService

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/v2/workflows/{workflowId}/pingWorkflowService"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch

            try {
                'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#pingWorkflowServiceById");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow to fetch

    try {
        final result = await api_instance.pingWorkflowServiceById(workflowId);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->pingWorkflowServiceById: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow to fetch

            try {
                'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#pingWorkflowServiceById");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)

    [apiInstance pingWorkflowServiceByIdWith:workflowId
                  completionHandler: ^('Boolean' output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow to fetch

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.pingWorkflowServiceById(workflowId, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class pingWorkflowServiceByIdExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)

                try {
                    'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.pingWorkflowServiceById: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow to fetch

    try {
        $result = $api_instance->pingWorkflowServiceById($workflowId);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->pingWorkflowServiceById: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow to fetch

    eval {
        my $result = $api_instance->pingWorkflowServiceById(workflowId => $workflowId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->pingWorkflowServiceById: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)

    try:
        api_response = api_instance.ping_workflow_service_by_id(workflowId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->pingWorkflowServiceById: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.pingWorkflowServiceById(workflowId, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow to fetch Required

## Responses

###

###

# retriggerInstance

Retrigger an instance

Retrigger an instance

    /v2/workflows/{workflowId}/{instanceId}/retrigger

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/v2/workflows/{workflowId}/{instanceId}/retrigger" \
     -d '{
      "authTokens" : [ {
        "provider" : "provider",
        "token" : "token"
      }, {
        "provider" : "provider",
        "token" : "token"
      } ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow
            String instanceId = instanceId_example; // String | ID of the instance to retrigger
            RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO |

            try {
                Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#retriggerInstance");
                e.printStackTrace();
            }
        }
    }

    import 'package:openapi/api.dart';

    final api_instance = DefaultApi();

    final String workflowId = new String(); // String | ID of the workflow
    final String instanceId = new String(); // String | ID of the instance to retrigger
    final RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = new RetriggerInstanceRequestDTO(); // RetriggerInstanceRequestDTO |

    try {
        final result = await api_instance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
        print(result);
    } catch (e) {
        print('Exception when calling DefaultApi->retriggerInstance: $e\n');
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workflowId = workflowId_example; // String | ID of the workflow
            String instanceId = instanceId_example; // String | ID of the instance to retrigger
            RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO |

            try {
                Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#retriggerInstance");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *workflowId = workflowId_example; // ID of the workflow (default to null)
    String *instanceId = instanceId_example; // ID of the instance to retrigger (default to null)
    RetriggerInstanceRequestDTO *retriggerInstanceRequestDTO = ; //

    // Retrigger an instance
    [apiInstance retriggerInstanceWith:workflowId
        instanceId:instanceId
        retriggerInstanceRequestDTO:retriggerInstanceRequestDTO
                  completionHandler: ^(Object output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var OrchestratorPlugin = require('orchestrator_plugin');

    // Create an instance of the API class
    var api = new OrchestratorPlugin.DefaultApi()
    var workflowId = workflowId_example; // {String} ID of the workflow
    var instanceId = instanceId_example; // {String} ID of the instance to retrigger
    var retriggerInstanceRequestDTO = ; // {RetriggerInstanceRequestDTO}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class retriggerInstanceExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workflowId = workflowId_example;  // String | ID of the workflow (default to null)
                var instanceId = instanceId_example;  // String | ID of the instance to retrigger (default to null)
                var retriggerInstanceRequestDTO = new RetriggerInstanceRequestDTO(); // RetriggerInstanceRequestDTO |

                try {
                    // Retrigger an instance
                    Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.retriggerInstance: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $workflowId = workflowId_example; // String | ID of the workflow
    $instanceId = instanceId_example; // String | ID of the instance to retrigger
    $retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO |

    try {
        $result = $api_instance->retriggerInstance($workflowId, $instanceId, $retriggerInstanceRequestDTO);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->retriggerInstance: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $workflowId = workflowId_example; # String | ID of the workflow
    my $instanceId = instanceId_example; # String | ID of the instance to retrigger
    my $retriggerInstanceRequestDTO = WWW::OPenAPIClient::Object::RetriggerInstanceRequestDTO->new(); # RetriggerInstanceRequestDTO |

    eval {
        my $result = $api_instance->retriggerInstance(workflowId => $workflowId, instanceId => $instanceId, retriggerInstanceRequestDTO => $retriggerInstanceRequestDTO);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->retriggerInstance: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    workflowId = workflowId_example # String | ID of the workflow (default to null)
    instanceId = instanceId_example # String | ID of the instance to retrigger (default to null)
    retriggerInstanceRequestDTO =  # RetriggerInstanceRequestDTO |

    try:
        # Retrigger an instance
        api_response = api_instance.retrigger_instance(workflowId, instanceId, retriggerInstanceRequestDTO)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->retriggerInstance: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workflowId = workflowId_example; // String
        let instanceId = instanceId_example; // String
        let retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO

        let mut context = DefaultApi::Context::default();
        let result = client.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workflowId* | String ID of the workflow Required
instanceId* | String ID of the instance to retrigger Required

Body parameters

Name | Description
--- | ---
retriggerInstanceRequestDTO * |

## Responses

###

###