import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of the user related to the Oauth client
        ClientCreateItem clientCreateItem = ; // ClientCreateItem | JSON API with the Oauth Client object to add
        try {
            ClientItem result = apiInstance.addClient(userId, clientCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addClient");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of the user related to the Oauth client
        ClientCreateItem clientCreateItem = ; // ClientCreateItem | JSON API with the Oauth Client object to add
        try {
            ClientItem result = apiInstance.addClient(userId, clientCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addClient");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *userId = userId_example; // ID of the user related to the Oauth client
ClientCreateItem *clientCreateItem = ; // JSON API with the Oauth Client object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addClientWith:userId
    clientCreateItem:clientCreateItem
              completionHandler: ^(ClientItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userId = userId_example; // {String} ID of the user related to the Oauth client

var clientCreateItem = ; // {ClientCreateItem} JSON API with the Oauth Client object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addClientExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userId = userId_example;  // String | ID of the user related to the Oauth client
            var clientCreateItem = new ClientCreateItem(); // ClientCreateItem | JSON API with the Oauth Client object to add

            try
            {
                ClientItem result = apiInstance.addClient(userId, clientCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addClient: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userId = userId_example; // String | ID of the user related to the Oauth client
$clientCreateItem = ; // ClientCreateItem | JSON API with the Oauth Client object to add

try {
    $result = $api_instance->addClient($userId, $clientCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addClient: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the event
        EventCreateItem eventCreateItem = ; // EventCreateItem | JSON API response with the Event object to add
        try {
            EventItem result = apiInstance.addEvent(processId, eventCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addEvent");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the event
        EventCreateItem eventCreateItem = ; // EventCreateItem | JSON API response with the Event object to add
        try {
            EventItem result = apiInstance.addEvent(processId, eventCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addEvent");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of the process related to the event
EventCreateItem *eventCreateItem = ; // JSON API response with the Event object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addEventWith:processId
    eventCreateItem:eventCreateItem
              completionHandler: ^(EventItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of the process related to the event

var eventCreateItem = ; // {EventCreateItem} JSON API response with the Event object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addEventExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of the process related to the event
            var eventCreateItem = new EventCreateItem(); // EventCreateItem | JSON API response with the Event object to add

            try
            {
                EventItem result = apiInstance.addEvent(processId, eventCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addEvent: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of the process related to the event
$eventCreateItem = ; // EventCreateItem | JSON API response with the Event object to add

try {
    $result = $api_instance->addEvent($processId, $eventCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addEvent: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        EventConnectorCreateItem eventConnectorCreateItem = ; // EventConnectorCreateItem | JSON API with the EventConnector object to add
        try {
            EventConnector_1 result = apiInstance.addEventConnector(processId, eventId, eventConnectorCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        EventConnectorCreateItem eventConnectorCreateItem = ; // EventConnectorCreateItem | JSON API with the EventConnector object to add
        try {
            EventConnector_1 result = apiInstance.addEventConnector(processId, eventId, eventConnectorCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *eventId = eventId_example; // ID of Event to fetch
EventConnectorCreateItem *eventConnectorCreateItem = ; // JSON API with the EventConnector object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addEventConnectorWith:processId
    eventId:eventId
    eventConnectorCreateItem:eventConnectorCreateItem
              completionHandler: ^(EventConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var eventId = eventId_example; // {String} ID of Event to fetch

var eventConnectorCreateItem = ; // {EventConnectorCreateItem} JSON API with the EventConnector object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addEventConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var eventId = eventId_example;  // String | ID of Event to fetch
            var eventConnectorCreateItem = new EventConnectorCreateItem(); // EventConnectorCreateItem | JSON API with the EventConnector object to add

            try
            {
                EventConnector_1 result = apiInstance.addEventConnector(processId, eventId, eventConnectorCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addEventConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$eventId = eventId_example; // String | ID of Event to fetch
$eventConnectorCreateItem = ; // EventConnectorCreateItem | JSON API with the EventConnector object to add

try {
    $result = $api_instance->addEventConnector($processId, $eventId, $eventConnectorCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addEventConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the flow
        FlowCreateItem flowCreateItem = ; // FlowCreateItem | JSON API response with the Flow object to add
        try {
            FlowItem result = apiInstance.addFlow(processId, flowCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addFlow");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the flow
        FlowCreateItem flowCreateItem = ; // FlowCreateItem | JSON API response with the Flow object to add
        try {
            FlowItem result = apiInstance.addFlow(processId, flowCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addFlow");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of the process related to the flow
FlowCreateItem *flowCreateItem = ; // JSON API response with the Flow object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addFlowWith:processId
    flowCreateItem:flowCreateItem
              completionHandler: ^(FlowItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of the process related to the flow

var flowCreateItem = ; // {FlowCreateItem} JSON API response with the Flow object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addFlowExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of the process related to the flow
            var flowCreateItem = new FlowCreateItem(); // FlowCreateItem | JSON API response with the Flow object to add

            try
            {
                FlowItem result = apiInstance.addFlow(processId, flowCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addFlow: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of the process related to the flow
$flowCreateItem = ; // FlowCreateItem | JSON API response with the Flow object to add

try {
    $result = $api_instance->addFlow($processId, $flowCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addFlow: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the gateway
        GatewayCreateItem gatewayCreateItem = ; // GatewayCreateItem | JSON API response with the gateway object to add
        try {
            GatewayItem result = apiInstance.addGateway(processId, gatewayCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGateway");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of the process related to the gateway
        GatewayCreateItem gatewayCreateItem = ; // GatewayCreateItem | JSON API response with the gateway object to add
        try {
            GatewayItem result = apiInstance.addGateway(processId, gatewayCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGateway");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of the process related to the gateway
GatewayCreateItem *gatewayCreateItem = ; // JSON API response with the gateway object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addGatewayWith:processId
    gatewayCreateItem:gatewayCreateItem
              completionHandler: ^(GatewayItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of the process related to the gateway

var gatewayCreateItem = ; // {GatewayCreateItem} JSON API response with the gateway object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addGatewayExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of the process related to the gateway
            var gatewayCreateItem = new GatewayCreateItem(); // GatewayCreateItem | JSON API response with the gateway object to add

            try
            {
                GatewayItem result = apiInstance.addGateway(processId, gatewayCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addGateway: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of the process related to the gateway
$gatewayCreateItem = ; // GatewayCreateItem | JSON API response with the gateway object to add

try {
    $result = $api_instance->addGateway($processId, $gatewayCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addGateway: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        GroupCreateItem groupCreateItem = ; // GroupCreateItem | JSON API with the Group object to add
        try {
            GroupItem result = apiInstance.addGroup(groupCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        GroupCreateItem groupCreateItem = ; // GroupCreateItem | JSON API with the Group object to add
        try {
            GroupItem result = apiInstance.addGroup(groupCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


GroupCreateItem *groupCreateItem = ; // JSON API with the Group object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addGroupWith:groupCreateItem
              completionHandler: ^(GroupItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var groupCreateItem = ; // {GroupCreateItem} JSON API with the Group object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var groupCreateItem = new GroupCreateItem(); // GroupCreateItem | JSON API with the Group object to add

            try
            {
                GroupItem result = apiInstance.addGroup(groupCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$groupCreateItem = ; // GroupCreateItem | JSON API with the Group object to add

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to be modified
        TaskAddGroupsItem taskAddGroupsItem = ; // TaskAddGroupsItem | JSON API with Groups ID's to add
        try {
            ResultSuccess result = apiInstance.addGroupsToTask(processId, taskId, taskAddGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGroupsToTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to be modified
        TaskAddGroupsItem taskAddGroupsItem = ; // TaskAddGroupsItem | JSON API with Groups ID's to add
        try {
            ResultSuccess result = apiInstance.addGroupsToTask(processId, taskId, taskAddGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addGroupsToTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *taskId = taskId_example; // ID of task to be modified
TaskAddGroupsItem *taskAddGroupsItem = ; // JSON API with Groups ID's to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addGroupsToTaskWith:processId
    taskId:taskId
    taskAddGroupsItem:taskAddGroupsItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var taskId = taskId_example; // {String} ID of task to be modified

var taskAddGroupsItem = ; // {TaskAddGroupsItem} JSON API with Groups ID's to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addGroupsToTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var taskId = taskId_example;  // String | ID of task to be modified
            var taskAddGroupsItem = new TaskAddGroupsItem(); // TaskAddGroupsItem | JSON API with Groups ID's to add

            try
            {
                ResultSuccess result = apiInstance.addGroupsToTask(processId, taskId, taskAddGroupsItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addGroupsToTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$taskId = taskId_example; // String | ID of task to be modified
$taskAddGroupsItem = ; // TaskAddGroupsItem | JSON API with Groups ID's to add

try {
    $result = $api_instance->addGroupsToTask($processId, $taskId, $taskAddGroupsItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addGroupsToTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        InputOutputCreateItem inputOutputCreateItem = ; // InputOutputCreateItem | Create and add a new Input/Output object with JSON API
        try {
            InputOutputItem result = apiInstance.addInputOutput(processId, taskId, inputOutputCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        InputOutputCreateItem inputOutputCreateItem = ; // InputOutputCreateItem | Create and add a new Input/Output object with JSON API
        try {
            InputOutputItem result = apiInstance.addInputOutput(processId, taskId, inputOutputCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to Input/Output object
String *taskId = taskId_example; // Task instance ID related to Input/Output object
InputOutputCreateItem *inputOutputCreateItem = ; // Create and add a new Input/Output object with JSON API

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addInputOutputWith:processId
    taskId:taskId
    inputOutputCreateItem:inputOutputCreateItem
              completionHandler: ^(InputOutputItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to Input/Output object

var taskId = taskId_example; // {String} Task instance ID related to Input/Output object

var inputOutputCreateItem = ; // {InputOutputCreateItem} Create and add a new Input/Output object with JSON API


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addInputOutputExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to Input/Output object
            var taskId = taskId_example;  // String | Task instance ID related to Input/Output object
            var inputOutputCreateItem = new InputOutputCreateItem(); // InputOutputCreateItem | Create and add a new Input/Output object with JSON API

            try
            {
                InputOutputItem result = apiInstance.addInputOutput(processId, taskId, inputOutputCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addInputOutput: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to Input/Output object
$taskId = taskId_example; // String | Task instance ID related to Input/Output object
$inputOutputCreateItem = ; // InputOutputCreateItem | Create and add a new Input/Output object with JSON API

try {
    $result = $api_instance->addInputOutput($processId, $taskId, $inputOutputCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addInputOutput: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the nstance
        InstanceCreateItem instanceCreateItem = ; // InstanceCreateItem | JSON API response with the Instance object to add
        try {
            InstanceItem result = apiInstance.addInstance(processId, instanceCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addInstance");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the nstance
        InstanceCreateItem instanceCreateItem = ; // InstanceCreateItem | JSON API response with the Instance object to add
        try {
            InstanceItem result = apiInstance.addInstance(processId, instanceCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addInstance");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the nstance
InstanceCreateItem *instanceCreateItem = ; // JSON API response with the Instance object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addInstanceWith:processId
    instanceCreateItem:instanceCreateItem
              completionHandler: ^(InstanceItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the nstance

var instanceCreateItem = ; // {InstanceCreateItem} JSON API response with the Instance object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addInstanceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the nstance
            var instanceCreateItem = new InstanceCreateItem(); // InstanceCreateItem | JSON API response with the Instance object to add

            try
            {
                InstanceItem result = apiInstance.addInstance(processId, instanceCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addInstance: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the nstance
$instanceCreateItem = ; // InstanceCreateItem | JSON API response with the Instance object to add

try {
    $result = $api_instance->addInstance($processId, $instanceCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addInstance: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        ProcessCreateItem processCreateItem = ; // ProcessCreateItem | JSON API response with the Process object to add
        try {
            ProcessItem result = apiInstance.addProcess(processCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addProcess");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        ProcessCreateItem processCreateItem = ; // ProcessCreateItem | JSON API response with the Process object to add
        try {
            ProcessItem result = apiInstance.addProcess(processCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addProcess");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


ProcessCreateItem *processCreateItem = ; // JSON API response with the Process object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addProcessWith:processCreateItem
              completionHandler: ^(ProcessItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processCreateItem = ; // {ProcessCreateItem} JSON API response with the Process object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addProcessExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processCreateItem = new ProcessCreateItem(); // ProcessCreateItem | JSON API response with the Process object to add

            try
            {
                ProcessItem result = apiInstance.addProcess(processCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addProcess: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processCreateItem = ; // ProcessCreateItem | JSON API response with the Process object to add

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the task
        TaskCreateItem taskCreateItem = ; // TaskCreateItem | JSON API with the Task object to add
        try {
            TaskItem result = apiInstance.addTask(processId, taskCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the task
        TaskCreateItem taskCreateItem = ; // TaskCreateItem | JSON API with the Task object to add
        try {
            TaskItem result = apiInstance.addTask(processId, taskCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the task
TaskCreateItem *taskCreateItem = ; // JSON API with the Task object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addTaskWith:processId
    taskCreateItem:taskCreateItem
              completionHandler: ^(TaskItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the task

var taskCreateItem = ; // {TaskCreateItem} JSON API with the Task object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the task
            var taskCreateItem = new TaskCreateItem(); // TaskCreateItem | JSON API with the Task object to add

            try
            {
                TaskItem result = apiInstance.addTask(processId, taskCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the task
$taskCreateItem = ; // TaskCreateItem | JSON API with the Task object to add

try {
    $result = $api_instance->addTask($processId, $taskCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        TaskConnectorCreateItem taskConnectorCreateItem = ; // TaskConnectorCreateItem | JSON API with the TaskConnector object to add
        try {
            TaskConnector_1 result = apiInstance.addTaskConnector(processId, taskId, taskConnectorCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        TaskConnectorCreateItem taskConnectorCreateItem = ; // TaskConnectorCreateItem | JSON API with the TaskConnector object to add
        try {
            TaskConnector_1 result = apiInstance.addTaskConnector(processId, taskId, taskConnectorCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *taskId = taskId_example; // ID of Task to fetch
TaskConnectorCreateItem *taskConnectorCreateItem = ; // JSON API with the TaskConnector object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addTaskConnectorWith:processId
    taskId:taskId
    taskConnectorCreateItem:taskConnectorCreateItem
              completionHandler: ^(TaskConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var taskId = taskId_example; // {String} ID of Task to fetch

var taskConnectorCreateItem = ; // {TaskConnectorCreateItem} JSON API with the TaskConnector object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addTaskConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var taskId = taskId_example;  // String | ID of Task to fetch
            var taskConnectorCreateItem = new TaskConnectorCreateItem(); // TaskConnectorCreateItem | JSON API with the TaskConnector object to add

            try
            {
                TaskConnector_1 result = apiInstance.addTaskConnector(processId, taskId, taskConnectorCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addTaskConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$taskId = taskId_example; // String | ID of Task to fetch
$taskConnectorCreateItem = ; // TaskConnectorCreateItem | JSON API with the TaskConnector object to add

try {
    $result = $api_instance->addTaskConnector($processId, $taskId, $taskConnectorCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addTaskConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        UserCreateItem userCreateItem = ; // UserCreateItem | JSON API with the User object to add
        try {
            UserItem result = apiInstance.addUser(userCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addUser");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        UserCreateItem userCreateItem = ; // UserCreateItem | JSON API with the User object to add
        try {
            UserItem result = apiInstance.addUser(userCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addUser");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


UserCreateItem *userCreateItem = ; // JSON API with the User object to add

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addUserWith:userCreateItem
              completionHandler: ^(UserItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userCreateItem = ; // {UserCreateItem} JSON API with the User object to add


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addUserExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userCreateItem = new UserCreateItem(); // UserCreateItem | JSON API with the User object to add

            try
            {
                UserItem result = apiInstance.addUser(userCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addUser: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userCreateItem = ; // UserCreateItem | JSON API with the User object to add

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modified
        GroupAddUsersItem groupAddUsersItem = ; // GroupAddUsersItem | JSON API response with array of users ID's
        try {
            ResultSuccess result = apiInstance.addUsersToGroup(id, groupAddUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addUsersToGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modified
        GroupAddUsersItem groupAddUsersItem = ; // GroupAddUsersItem | JSON API response with array of users ID's
        try {
            ResultSuccess result = apiInstance.addUsersToGroup(id, groupAddUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#addUsersToGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to be modified
GroupAddUsersItem *groupAddUsersItem = ; // JSON API response with array of users ID's

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance addUsersToGroupWith:id
    groupAddUsersItem:groupAddUsersItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to be modified

var groupAddUsersItem = ; // {GroupAddUsersItem} JSON API response with array of users ID's


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class addUsersToGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to be modified
            var groupAddUsersItem = new GroupAddUsersItem(); // GroupAddUsersItem | JSON API response with array of users ID's

            try
            {
                ResultSuccess result = apiInstance.addUsersToGroup(id, groupAddUsersItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.addUsersToGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to be modified
$groupAddUsersItem = ; // GroupAddUsersItem | JSON API response with array of users ID's

try {
    $result = $api_instance->addUsersToGroup($id, $groupAddUsersItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->addUsersToGroup: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | User ID
        String clientId = clientId_example; // String | ID of client to delete
        try {
            ResultSuccess result = apiInstance.deleteClient(userId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteClient");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | User ID
        String clientId = clientId_example; // String | ID of client to delete
        try {
            ResultSuccess result = apiInstance.deleteClient(userId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteClient");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *userId = userId_example; // User ID
String *clientId = clientId_example; // ID of client to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteClientWith:userId
    clientId:clientId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userId = userId_example; // {String} User ID

var clientId = clientId_example; // {String} ID of client to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteClientExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userId = userId_example;  // String | User ID
            var clientId = clientId_example;  // String | ID of client to delete

            try
            {
                ResultSuccess result = apiInstance.deleteClient(userId, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteClient: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userId = userId_example; // String | User ID
$clientId = clientId_example; // String | ID of client to delete

try {
    $result = $api_instance->deleteClient($userId, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteClient: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String eventId = eventId_example; // String | ID of event to delete
        try {
            ResultSuccess result = apiInstance.deleteEvent(processId, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteEvent");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String eventId = eventId_example; // String | ID of event to delete
        try {
            ResultSuccess result = apiInstance.deleteEvent(processId, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteEvent");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *eventId = eventId_example; // ID of event to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteEventWith:processId
    eventId:eventId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var eventId = eventId_example; // {String} ID of event to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteEventExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var eventId = eventId_example;  // String | ID of event to delete

            try
            {
                ResultSuccess result = apiInstance.deleteEvent(processId, eventId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteEvent: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$eventId = eventId_example; // String | ID of event to delete

try {
    $result = $api_instance->deleteEvent($processId, $eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteEvent: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of of Process item
        String eventId = eventId_example; // String | ID of item to fetch
        String connectorId = connectorId_example; // String | ID of EventConnector to fetch
        try {
            ResultSuccess result = apiInstance.deleteEventConnector(processId, eventId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of of Process item
        String eventId = eventId_example; // String | ID of item to fetch
        String connectorId = connectorId_example; // String | ID of EventConnector to fetch
        try {
            ResultSuccess result = apiInstance.deleteEventConnector(processId, eventId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of of Process item
String *eventId = eventId_example; // ID of item to fetch
String *connectorId = connectorId_example; // ID of EventConnector to fetch

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteEventConnectorWith:processId
    eventId:eventId
    connectorId:connectorId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of of Process item

var eventId = eventId_example; // {String} ID of item to fetch

var connectorId = connectorId_example; // {String} ID of EventConnector to fetch


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteEventConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of of Process item
            var eventId = eventId_example;  // String | ID of item to fetch
            var connectorId = connectorId_example;  // String | ID of EventConnector to fetch

            try
            {
                ResultSuccess result = apiInstance.deleteEventConnector(processId, eventId, connectorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteEventConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of of Process item
$eventId = eventId_example; // String | ID of item to fetch
$connectorId = connectorId_example; // String | ID of EventConnector to fetch

try {
    $result = $api_instance->deleteEventConnector($processId, $eventId, $connectorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteEventConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String flowId = flowId_example; // String | ID of flow to delete
        try {
            ResultSuccess result = apiInstance.deleteFlow(processId, flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String flowId = flowId_example; // String | ID of flow to delete
        try {
            ResultSuccess result = apiInstance.deleteFlow(processId, flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *flowId = flowId_example; // ID of flow to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteFlowWith:processId
    flowId:flowId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var flowId = flowId_example; // {String} ID of flow to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteFlowExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var flowId = flowId_example;  // String | ID of flow to delete

            try
            {
                ResultSuccess result = apiInstance.deleteFlow(processId, flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteFlow: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$flowId = flowId_example; // String | ID of flow to delete

try {
    $result = $api_instance->deleteFlow($processId, $flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteFlow: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String gatewayId = gatewayId_example; // String | ID of Process to delete
        try {
            ResultSuccess result = apiInstance.deleteGateway(processId, gatewayId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteGateway");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String gatewayId = gatewayId_example; // String | ID of Process to delete
        try {
            ResultSuccess result = apiInstance.deleteGateway(processId, gatewayId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteGateway");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *gatewayId = gatewayId_example; // ID of Process to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteGatewayWith:processId
    gatewayId:gatewayId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var gatewayId = gatewayId_example; // {String} ID of Process to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteGatewayExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var gatewayId = gatewayId_example;  // String | ID of Process to delete

            try
            {
                ResultSuccess result = apiInstance.deleteGateway(processId, gatewayId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteGateway: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$gatewayId = gatewayId_example; // String | ID of Process to delete

try {
    $result = $api_instance->deleteGateway($processId, $gatewayId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteGateway: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to delete
        try {
            ResultSuccess result = apiInstance.deleteGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to delete
        try {
            ResultSuccess result = apiInstance.deleteGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteGroupWith:id
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to delete

            try
            {
                ResultSuccess result = apiInstance.deleteGroup(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to delete

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | Input/Output ID to fetch
        try {
            ResultSuccess result = apiInstance.deleteInputOutput(processId, taskId, inputoutputUid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | Input/Output ID to fetch
        try {
            ResultSuccess result = apiInstance.deleteInputOutput(processId, taskId, inputoutputUid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the Input/Output object
String *taskId = taskId_example; // Task instance ID related to Input/Output object
String *inputoutputUid = inputoutputUid_example; // Input/Output ID to fetch

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteInputOutputWith:processId
    taskId:taskId
    inputoutputUid:inputoutputUid
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the Input/Output object

var taskId = taskId_example; // {String} Task instance ID related to Input/Output object

var inputoutputUid = inputoutputUid_example; // {String} Input/Output ID to fetch


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteInputOutputExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the Input/Output object
            var taskId = taskId_example;  // String | Task instance ID related to Input/Output object
            var inputoutputUid = inputoutputUid_example;  // String | Input/Output ID to fetch

            try
            {
                ResultSuccess result = apiInstance.deleteInputOutput(processId, taskId, inputoutputUid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteInputOutput: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the Input/Output object
$taskId = taskId_example; // String | Task instance ID related to Input/Output object
$inputoutputUid = inputoutputUid_example; // String | Input/Output ID to fetch

try {
    $result = $api_instance->deleteInputOutput($processId, $taskId, $inputoutputUid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteInputOutput: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String instanceId = instanceId_example; // String | ID of instance to delete
        try {
            ResultSuccess result = apiInstance.deleteInstance(processId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteInstance");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String instanceId = instanceId_example; // String | ID of instance to delete
        try {
            ResultSuccess result = apiInstance.deleteInstance(processId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteInstance");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *instanceId = instanceId_example; // ID of instance to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteInstanceWith:processId
    instanceId:instanceId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var instanceId = instanceId_example; // {String} ID of instance to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteInstanceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var instanceId = instanceId_example;  // String | ID of instance to delete

            try
            {
                ResultSuccess result = apiInstance.deleteInstance(processId, instanceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteInstance: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$instanceId = instanceId_example; // String | ID of instance to delete

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | Process ID to delete
        try {
            ResultSuccess result = apiInstance.deleteProcess(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteProcess");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | Process ID to delete
        try {
            ResultSuccess result = apiInstance.deleteProcess(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteProcess");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // Process ID to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteProcessWith:id
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} Process ID to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteProcessExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | Process ID to delete

            try
            {
                ResultSuccess result = apiInstance.deleteProcess(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteProcess: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | Process ID to delete

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to delete
        try {
            ResultSuccess result = apiInstance.deleteTask(processId, taskId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to delete
        try {
            ResultSuccess result = apiInstance.deleteTask(processId, taskId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *taskId = taskId_example; // ID of task to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteTaskWith:processId
    taskId:taskId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var taskId = taskId_example; // {String} ID of task to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var taskId = taskId_example;  // String | ID of task to delete

            try
            {
                ResultSuccess result = apiInstance.deleteTask(processId, taskId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$taskId = taskId_example; // String | ID of task to delete

try {
    $result = $api_instance->deleteTask($processId, $taskId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process item to fetch
        String taskId = taskId_example; // String | ID of Task item to fetch
        String connectorId = connectorId_example; // String | ID of TaskConnector to fetch
        try {
            ResultSuccess result = apiInstance.deleteTaskConnector(processId, taskId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process item to fetch
        String taskId = taskId_example; // String | ID of Task item to fetch
        String connectorId = connectorId_example; // String | ID of TaskConnector to fetch
        try {
            ResultSuccess result = apiInstance.deleteTaskConnector(processId, taskId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process item to fetch
String *taskId = taskId_example; // ID of Task item to fetch
String *connectorId = connectorId_example; // ID of TaskConnector to fetch

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteTaskConnectorWith:processId
    taskId:taskId
    connectorId:connectorId
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process item to fetch

var taskId = taskId_example; // {String} ID of Task item to fetch

var connectorId = connectorId_example; // {String} ID of TaskConnector to fetch


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteTaskConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process item to fetch
            var taskId = taskId_example;  // String | ID of Task item to fetch
            var connectorId = connectorId_example;  // String | ID of TaskConnector to fetch

            try
            {
                ResultSuccess result = apiInstance.deleteTaskConnector(processId, taskId, connectorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteTaskConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process item to fetch
$taskId = taskId_example; // String | ID of Task item to fetch
$connectorId = connectorId_example; // String | ID of TaskConnector to fetch

try {
    $result = $api_instance->deleteTaskConnector($processId, $taskId, $connectorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->deleteTaskConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of user to delete
        try {
            ResultSuccess result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of user to delete
        try {
            ResultSuccess result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of user to delete

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance deleteUserWith:id
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of user to delete


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of user to delete

            try
            {
                ResultSuccess result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.deleteUser: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of user to delete

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the event
        String eventId = eventId_example; // String | ID of event to trigger
        TriggerEventCreateItem triggerEventCreateItem = ; // TriggerEventCreateItem | Json with some parameters
        try {
            DataModelItem_1 result = apiInstance.eventTrigger(processId, eventId, triggerEventCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#eventTrigger");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the event
        String eventId = eventId_example; // String | ID of event to trigger
        TriggerEventCreateItem triggerEventCreateItem = ; // TriggerEventCreateItem | Json with some parameters
        try {
            DataModelItem_1 result = apiInstance.eventTrigger(processId, eventId, triggerEventCreateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#eventTrigger");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the event
String *eventId = eventId_example; // ID of event to trigger
TriggerEventCreateItem *triggerEventCreateItem = ; // Json with some parameters

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance eventTriggerWith:processId
    eventId:eventId
    triggerEventCreateItem:triggerEventCreateItem
              completionHandler: ^(DataModelItem_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the event

var eventId = eventId_example; // {String} ID of event to trigger

var triggerEventCreateItem = ; // {TriggerEventCreateItem} Json with some parameters


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class eventTriggerExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the event
            var eventId = eventId_example;  // String | ID of event to trigger
            var triggerEventCreateItem = new TriggerEventCreateItem(); // TriggerEventCreateItem | Json with some parameters

            try
            {
                DataModelItem_1 result = apiInstance.eventTrigger(processId, eventId, triggerEventCreateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.eventTrigger: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the event
$eventId = eventId_example; // String | ID of event to trigger
$triggerEventCreateItem = ; // TriggerEventCreateItem | Json with some parameters

try {
    $result = $api_instance->eventTrigger($processId, $eventId, $triggerEventCreateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->eventTrigger: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of user to retrieve
        String clientId = clientId_example; // String | ID of client to retrieve
        try {
            ClientItem result = apiInstance.findClientById(userId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findClientById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of user to retrieve
        String clientId = clientId_example; // String | ID of client to retrieve
        try {
            ClientItem result = apiInstance.findClientById(userId, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findClientById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *userId = userId_example; // ID of user to retrieve
String *clientId = clientId_example; // ID of client to retrieve

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findClientByIdWith:userId
    clientId:clientId
              completionHandler: ^(ClientItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userId = userId_example; // {String} ID of user to retrieve

var clientId = clientId_example; // {String} ID of client to retrieve


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findClientByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userId = userId_example;  // String | ID of user to retrieve
            var clientId = clientId_example;  // String | ID of client to retrieve

            try
            {
                ClientItem result = apiInstance.findClientById(userId, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findClientById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userId = userId_example; // String | ID of user to retrieve
$clientId = clientId_example; // String | ID of client to retrieve

try {
    $result = $api_instance->findClientById($userId, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findClientById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | User ID related to the clients
        Integer pagefindProcessById = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            ClientCollection result = apiInstance.findClients(userId, pagefindProcessById, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findClients");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | User ID related to the clients
        Integer pagefindProcessById = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            ClientCollection result = apiInstance.findClients(userId, pagefindProcessById, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findClients");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *userId = userId_example; // User ID related to the clients
Integer *pagefindProcessById = 56; // Page numbers to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findClientsWith:userId
    pagefindProcessById:pagefindProcessById
    perPage:perPage
              completionHandler: ^(ClientCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userId = userId_example; // {String} User ID related to the clients

var opts = { 
  'pagefindProcessById': 56, // {Integer} Page numbers to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findClientsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userId = userId_example;  // String | User ID related to the clients
            var pagefindProcessById = 56;  // Integer | Page numbers to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                ClientCollection result = apiInstance.findClients(userId, pagefindProcessById, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findClients: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userId = userId_example; // String | User ID related to the clients
$pagefindProcessById = 56; // Integer | Page numbers to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findClients($userId, $pagefindProcessById, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findClients: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String instanceId = instanceId_example; // String | ID of instance to return
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            DataModelItem_1 result = apiInstance.findDataModel(processId, instanceId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findDataModel");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String instanceId = instanceId_example; // String | ID of instance to return
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            DataModelItem_1 result = apiInstance.findDataModel(processId, instanceId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findDataModel");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *instanceId = instanceId_example; // ID of instance to return
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findDataModelWith:processId
    instanceId:instanceId
    page:page
    perPage:perPage
              completionHandler: ^(DataModelItem_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var instanceId = instanceId_example; // {String} ID of instance to return

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findDataModelExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var instanceId = instanceId_example;  // String | ID of instance to return
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                DataModelItem_1 result = apiInstance.findDataModel(processId, instanceId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findDataModel: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$instanceId = instanceId_example; // String | ID of instance to return
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findDataModel($processId, $instanceId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findDataModel: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String eventId = eventId_example; // String | ID of event to return
        try {
            EventItem result = apiInstance.findEventById(processId, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String eventId = eventId_example; // String | ID of event to return
        try {
            EventItem result = apiInstance.findEventById(processId, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *eventId = eventId_example; // ID of event to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findEventByIdWith:processId
    eventId:eventId
              completionHandler: ^(EventItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var eventId = eventId_example; // {String} ID of event to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findEventByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var eventId = eventId_example;  // String | ID of event to return

            try
            {
                EventItem result = apiInstance.findEventById(processId, eventId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findEventById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$eventId = eventId_example; // String | ID of event to return

try {
    $result = $api_instance->findEventById($processId, $eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findEventById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        String connectorId = connectorId_example; // String | ID of EventConnector to fetch
        try {
            EventConnector_1 result = apiInstance.findEventConnectorById(processId, eventId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventConnectorById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        String connectorId = connectorId_example; // String | ID of EventConnector to fetch
        try {
            EventConnector_1 result = apiInstance.findEventConnectorById(processId, eventId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventConnectorById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *eventId = eventId_example; // ID of Event to fetch
String *connectorId = connectorId_example; // ID of EventConnector to fetch

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findEventConnectorByIdWith:processId
    eventId:eventId
    connectorId:connectorId
              completionHandler: ^(EventConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var eventId = eventId_example; // {String} ID of Event to fetch

var connectorId = connectorId_example; // {String} ID of EventConnector to fetch


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findEventConnectorByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var eventId = eventId_example;  // String | ID of Event to fetch
            var connectorId = connectorId_example;  // String | ID of EventConnector to fetch

            try
            {
                EventConnector_1 result = apiInstance.findEventConnectorById(processId, eventId, connectorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findEventConnectorById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$eventId = eventId_example; // String | ID of Event to fetch
$connectorId = connectorId_example; // String | ID of EventConnector to fetch

try {
    $result = $api_instance->findEventConnectorById($processId, $eventId, $connectorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findEventConnectorById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Task to fetch
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            EventConnectorsCollection result = apiInstance.findEventConnectors(processId, eventId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventConnectors");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Task to fetch
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            EventConnectorsCollection result = apiInstance.findEventConnectors(processId, eventId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEventConnectors");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *eventId = eventId_example; // ID of Task to fetch
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findEventConnectorsWith:processId
    eventId:eventId
    page:page
    perPage:perPage
              completionHandler: ^(EventConnectorsCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var eventId = eventId_example; // {String} ID of Task to fetch

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findEventConnectorsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var eventId = eventId_example;  // String | ID of Task to fetch
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                EventConnectorsCollection result = apiInstance.findEventConnectors(processId, eventId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findEventConnectors: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$eventId = eventId_example; // String | ID of Task to fetch
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findEventConnectors($processId, $eventId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findEventConnectors: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the event
        Integer page = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            EventCollection result = apiInstance.findEvents(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEvents");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the event
        Integer page = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            EventCollection result = apiInstance.findEvents(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findEvents");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process related to the event
Integer *page = 56; // Page numbers to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findEventsWith:processId
    page:page
    perPage:perPage
              completionHandler: ^(EventCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process related to the event

var opts = { 
  'page': 56, // {Integer} Page numbers to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findEventsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process related to the event
            var page = 56;  // Integer | Page numbers to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                EventCollection result = apiInstance.findEvents(processId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findEvents: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process related to the event
$page = 56; // Integer | Page numbers to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findEvents($processId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findEvents: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String flowId = flowId_example; // String | ID of flow to return
        try {
            FlowItem result = apiInstance.findFlowById(processId, flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findFlowById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String flowId = flowId_example; // String | ID of flow to return
        try {
            FlowItem result = apiInstance.findFlowById(processId, flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findFlowById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *flowId = flowId_example; // ID of flow to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findFlowByIdWith:processId
    flowId:flowId
              completionHandler: ^(FlowItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var flowId = flowId_example; // {String} ID of flow to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findFlowByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var flowId = flowId_example;  // String | ID of flow to return

            try
            {
                FlowItem result = apiInstance.findFlowById(processId, flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findFlowById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$flowId = flowId_example; // String | ID of flow to return

try {
    $result = $api_instance->findFlowById($processId, $flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findFlowById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the flow
        Integer page = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            FlowCollection result = apiInstance.findFlows(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findFlows");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the flow
        Integer page = 56; // Integer | Page numbers to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            FlowCollection result = apiInstance.findFlows(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findFlows");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process related to the flow
Integer *page = 56; // Page numbers to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findFlowsWith:processId
    page:page
    perPage:perPage
              completionHandler: ^(FlowCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process related to the flow

var opts = { 
  'page': 56, // {Integer} Page numbers to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findFlowsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process related to the flow
            var page = 56;  // Integer | Page numbers to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                FlowCollection result = apiInstance.findFlows(processId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findFlows: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process related to the flow
$page = 56; // Integer | Page numbers to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findFlows($processId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findFlows: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String gatewayId = gatewayId_example; // String | ID of gateway to return
        try {
            GatewayItem result = apiInstance.findGatewayById(processId, gatewayId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGatewayById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String gatewayId = gatewayId_example; // String | ID of gateway to return
        try {
            GatewayItem result = apiInstance.findGatewayById(processId, gatewayId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGatewayById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *gatewayId = gatewayId_example; // ID of gateway to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findGatewayByIdWith:processId
    gatewayId:gatewayId
              completionHandler: ^(GatewayItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var gatewayId = gatewayId_example; // {String} ID of gateway to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findGatewayByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var gatewayId = gatewayId_example;  // String | ID of gateway to return

            try
            {
                GatewayItem result = apiInstance.findGatewayById(processId, gatewayId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findGatewayById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$gatewayId = gatewayId_example; // String | ID of gateway to return

try {
    $result = $api_instance->findGatewayById($processId, $gatewayId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findGatewayById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the gateway
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            GatewayCollection result = apiInstance.findGateways(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGateways");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process related to the gateway
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            GatewayCollection result = apiInstance.findGateways(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGateways");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process related to the gateway
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findGatewaysWith:processId
    page:page
    perPage:perPage
              completionHandler: ^(GatewayCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process related to the gateway

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findGatewaysExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process related to the gateway
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                GatewayCollection result = apiInstance.findGateways(processId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findGateways: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process related to the gateway
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findGateways($processId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findGateways: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to return
        try {
            GroupItem result = apiInstance.findGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGroupById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to return
        try {
            GroupItem result = apiInstance.findGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGroupById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findGroupByIdWith:id
              completionHandler: ^(GroupItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findGroupByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to return

            try
            {
                GroupItem result = apiInstance.findGroupById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findGroupById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to return

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            GroupCollection result = apiInstance.findGroups(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGroups");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            GroupCollection result = apiInstance.findGroups(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findGroups");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findGroupsWith:page
    perPage:perPage
              completionHandler: ^(GroupCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findGroupsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                GroupCollection result = apiInstance.findGroups(page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findGroups: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findGroups($page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findGroups: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to the Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to return
        try {
            InputOutputItem result = apiInstance.findInputOutputById(processId, taskId, inputoutputUid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInputOutputById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to the Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to return
        try {
            InputOutputItem result = apiInstance.findInputOutputById(processId, taskId, inputoutputUid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInputOutputById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the Input/Output object
String *taskId = taskId_example; // Task instance ID related to the Input/Output object
String *inputoutputUid = inputoutputUid_example; // ID of Input/Output to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findInputOutputByIdWith:processId
    taskId:taskId
    inputoutputUid:inputoutputUid
              completionHandler: ^(InputOutputItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the Input/Output object

var taskId = taskId_example; // {String} Task instance ID related to the Input/Output object

var inputoutputUid = inputoutputUid_example; // {String} ID of Input/Output to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findInputOutputByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the Input/Output object
            var taskId = taskId_example;  // String | Task instance ID related to the Input/Output object
            var inputoutputUid = inputoutputUid_example;  // String | ID of Input/Output to return

            try
            {
                InputOutputItem result = apiInstance.findInputOutputById(processId, taskId, inputoutputUid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findInputOutputById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the Input/Output object
$taskId = taskId_example; // String | Task instance ID related to the Input/Output object
$inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to return

try {
    $result = $api_instance->findInputOutputById($processId, $taskId, $inputoutputUid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findInputOutputById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            InputOutputCollection result = apiInstance.findInputOutputs(processId, taskId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInputOutputs");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to Input/Output object
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            InputOutputCollection result = apiInstance.findInputOutputs(processId, taskId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInputOutputs");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to Input/Output object
String *taskId = taskId_example; // Task instance ID related to Input/Output object
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findInputOutputsWith:processId
    taskId:taskId
    page:page
    perPage:perPage
              completionHandler: ^(InputOutputCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to Input/Output object

var taskId = taskId_example; // {String} Task instance ID related to Input/Output object

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findInputOutputsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to Input/Output object
            var taskId = taskId_example;  // String | Task instance ID related to Input/Output object
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                InputOutputCollection result = apiInstance.findInputOutputs(processId, taskId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findInputOutputs: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to Input/Output object
$taskId = taskId_example; // String | Task instance ID related to Input/Output object
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findInputOutputs($processId, $taskId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findInputOutputs: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String instanceId = instanceId_example; // String | ID of instance to return
        try {
            InstanceItem result = apiInstance.findInstanceById(processId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInstanceById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String instanceId = instanceId_example; // String | ID of instance to return
        try {
            InstanceItem result = apiInstance.findInstanceById(processId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInstanceById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *instanceId = instanceId_example; // ID of instance to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findInstanceByIdWith:processId
    instanceId:instanceId
              completionHandler: ^(InstanceItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var instanceId = instanceId_example; // {String} ID of instance to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findInstanceByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var instanceId = instanceId_example;  // String | ID of instance to return

            try
            {
                InstanceItem result = apiInstance.findInstanceById(processId, instanceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findInstanceById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$instanceId = instanceId_example; // String | ID of instance to return

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the instances
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            InstanceCollection result = apiInstance.findInstances(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInstances");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the instances
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            InstanceCollection result = apiInstance.findInstances(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findInstances");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the instances
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findInstancesWith:processId
    page:page
    perPage:perPage
              completionHandler: ^(InstanceCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the instances

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findInstancesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the instances
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                InstanceCollection result = apiInstance.findInstances(processId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findInstances: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the instances
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findInstances($processId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findInstances: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of process to return
        try {
            ProcessItem result = apiInstance.findProcessById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findProcessById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of process to return
        try {
            ProcessItem result = apiInstance.findProcessById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findProcessById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of process to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findProcessByIdWith:id
              completionHandler: ^(ProcessItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of process to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findProcessByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of process to return

            try
            {
                ProcessItem result = apiInstance.findProcessById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findProcessById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of process to return

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            ProcessCollection result = apiInstance.findProcesses(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findProcesses");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            ProcessCollection result = apiInstance.findProcesses(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findProcesses");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findProcessesWith:page
    perPage:perPage
              completionHandler: ^(ProcessCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findProcessesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                ProcessCollection result = apiInstance.findProcesses(page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findProcesses: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findProcesses($page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findProcesses: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String taskId = taskId_example; // String | ID of task to return
        try {
            TaskItem result = apiInstance.findTaskById(processId, taskId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to return
        String taskId = taskId_example; // String | ID of task to return
        try {
            TaskItem result = apiInstance.findTaskById(processId, taskId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to return
String *taskId = taskId_example; // ID of task to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTaskByIdWith:processId
    taskId:taskId
              completionHandler: ^(TaskItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to return

var taskId = taskId_example; // {String} ID of task to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTaskByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to return
            var taskId = taskId_example;  // String | ID of task to return

            try
            {
                TaskItem result = apiInstance.findTaskById(processId, taskId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTaskById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to return
$taskId = taskId_example; // String | ID of task to return

try {
    $result = $api_instance->findTaskById($processId, $taskId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTaskById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        String connectorId = connectorId_example; // String | ID of TaskConnector to fetch
        try {
            TaskConnector_1 result = apiInstance.findTaskConnectorById(processId, taskId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskConnectorById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        String connectorId = connectorId_example; // String | ID of TaskConnector to fetch
        try {
            TaskConnector_1 result = apiInstance.findTaskConnectorById(processId, taskId, connectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskConnectorById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *taskId = taskId_example; // ID of Task to fetch
String *connectorId = connectorId_example; // ID of TaskConnector to fetch

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTaskConnectorByIdWith:processId
    taskId:taskId
    connectorId:connectorId
              completionHandler: ^(TaskConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var taskId = taskId_example; // {String} ID of Task to fetch

var connectorId = connectorId_example; // {String} ID of TaskConnector to fetch


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTaskConnectorByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var taskId = taskId_example;  // String | ID of Task to fetch
            var connectorId = connectorId_example;  // String | ID of TaskConnector to fetch

            try
            {
                TaskConnector_1 result = apiInstance.findTaskConnectorById(processId, taskId, connectorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTaskConnectorById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$taskId = taskId_example; // String | ID of Task to fetch
$connectorId = connectorId_example; // String | ID of TaskConnector to fetch

try {
    $result = $api_instance->findTaskConnectorById($processId, $taskId, $connectorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTaskConnectorById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            TaskConnectorsCollection result = apiInstance.findTaskConnectors(processId, taskId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskConnectors");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            TaskConnectorsCollection result = apiInstance.findTaskConnectors(processId, taskId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskConnectors");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *taskId = taskId_example; // ID of Task to fetch
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTaskConnectorsWith:processId
    taskId:taskId
    page:page
    perPage:perPage
              completionHandler: ^(TaskConnectorsCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var taskId = taskId_example; // {String} ID of Task to fetch

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTaskConnectorsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var taskId = taskId_example;  // String | ID of Task to fetch
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                TaskConnectorsCollection result = apiInstance.findTaskConnectors(processId, taskId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTaskConnectors: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$taskId = taskId_example; // String | ID of Task to fetch
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findTaskConnectors($processId, $taskId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTaskConnectors: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String taskInstanceId = taskInstanceId_example; // String | ID of task instance to return
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            inline_response_200 result = apiInstance.findTaskInstanceById(taskInstanceId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskInstanceById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String taskInstanceId = taskInstanceId_example; // String | ID of task instance to return
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            inline_response_200 result = apiInstance.findTaskInstanceById(taskInstanceId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskInstanceById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *taskInstanceId = taskInstanceId_example; // ID of task instance to return
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTaskInstanceByIdWith:taskInstanceId
    page:page
    perPage:perPage
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var taskInstanceId = taskInstanceId_example; // {String} ID of task instance to return

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTaskInstanceByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var taskInstanceId = taskInstanceId_example;  // String | ID of task instance to return
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                inline_response_200 result = apiInstance.findTaskInstanceById(taskInstanceId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTaskInstanceById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$taskInstanceId = taskInstanceId_example; // String | ID of task instance to return
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findTaskInstanceById($taskInstanceId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTaskInstanceById: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            TaskInstanceCollection result = apiInstance.findTaskInstances(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskInstances");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            TaskInstanceCollection result = apiInstance.findTaskInstances(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTaskInstances");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTaskInstancesWith:page
    perPage:perPage
              completionHandler: ^(TaskInstanceCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTaskInstancesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                TaskInstanceCollection result = apiInstance.findTaskInstances(page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTaskInstances: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findTaskInstances($page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTaskInstances: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process relative to task
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            TaskCollection result = apiInstance.findTasks(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTasks");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process relative to task
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per Page
        try {
            TaskCollection result = apiInstance.findTasks(processId, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findTasks");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process relative to task
Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per Page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findTasksWith:processId
    page:page
    perPage:perPage
              completionHandler: ^(TaskCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process relative to task

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per Page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findTasksExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process relative to task
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per Page (optional)  (default to 15)

            try
            {
                TaskCollection result = apiInstance.findTasks(processId, page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findTasks: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process relative to task
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per Page

try {
    $result = $api_instance->findTasks($processId, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findTasks: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of the user to return
        try {
            UserItem result = apiInstance.findUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findUserById");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of the user to return
        try {
            UserItem result = apiInstance.findUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findUserById");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of the user to return

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findUserByIdWith:id
              completionHandler: ^(UserItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of the user to return


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findUserByIdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of the user to return

            try
            {
                UserItem result = apiInstance.findUserById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findUserById: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of the user to return

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            UserCollection result = apiInstance.findUsers(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findUsers");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            UserCollection result = apiInstance.findUsers(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#findUsers");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance findUsersWith:page
    perPage:perPage
              completionHandler: ^(UserCollection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class findUsersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                UserCollection result = apiInstance.findUsers(page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.findUsers: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->findUsers($page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->findUsers: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        BpmnImportItem bpmnImportItem = ; // BpmnImportItem | JSON API with the BPMN file to import
        try {
            ProcessCollection_1 result = apiInstance.importBpmnFile(bpmnImportItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#importBpmnFile");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        BpmnImportItem bpmnImportItem = ; // BpmnImportItem | JSON API with the BPMN file to import
        try {
            ProcessCollection_1 result = apiInstance.importBpmnFile(bpmnImportItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#importBpmnFile");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


BpmnImportItem *bpmnImportItem = ; // JSON API with the BPMN file to import

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance importBpmnFileWith:bpmnImportItem
              completionHandler: ^(ProcessCollection_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var bpmnImportItem = ; // {BpmnImportItem} JSON API with the BPMN file to import


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class importBpmnFileExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var bpmnImportItem = new BpmnImportItem(); // BpmnImportItem | JSON API with the BPMN file to import

            try
            {
                ProcessCollection_1 result = apiInstance.importBpmnFile(bpmnImportItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.importBpmnFile: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$bpmnImportItem = ; // BpmnImportItem | JSON API with the BPMN file to import

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

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            UserItem result = apiInstance.myselfUser(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#myselfUser");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        Integer page = 56; // Integer | Page number to fetch
        Integer perPage = 56; // Integer | Amount of items per page
        try {
            UserItem result = apiInstance.myselfUser(page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#myselfUser");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


Integer *page = 56; // Page number to fetch (optional) (default to 1)
Integer *perPage = 56; // Amount of items per page (optional) (default to 15)

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance myselfUserWith:page
    perPage:perPage
              completionHandler: ^(UserItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var opts = { 
  'page': 56, // {Integer} Page number to fetch
  'perPage': 56 // {Integer} Amount of items per page
};

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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class myselfUserExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var page = 56;  // Integer | Page number to fetch (optional)  (default to 1)
            var perPage = 56;  // Integer | Amount of items per page (optional)  (default to 15)

            try
            {
                UserItem result = apiInstance.myselfUser(page, perPage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.myselfUser: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$page = 56; // Integer | Page number to fetch
$perPage = 56; // Integer | Amount of items per page

try {
    $result = $api_instance->myselfUser($page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->myselfUser: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | Task ID
        TaskRemoveGroupsItem taskRemoveGroupsItem = ; // TaskRemoveGroupsItem | JSON API response with Groups IDs to remove
        try {
            ResultSuccess result = apiInstance.removeGroupsFromTask(processId, taskId, taskRemoveGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#removeGroupsFromTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | Task ID
        TaskRemoveGroupsItem taskRemoveGroupsItem = ; // TaskRemoveGroupsItem | JSON API response with Groups IDs to remove
        try {
            ResultSuccess result = apiInstance.removeGroupsFromTask(processId, taskId, taskRemoveGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#removeGroupsFromTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *taskId = taskId_example; // Task ID
TaskRemoveGroupsItem *taskRemoveGroupsItem = ; // JSON API response with Groups IDs to remove

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance removeGroupsFromTaskWith:processId
    taskId:taskId
    taskRemoveGroupsItem:taskRemoveGroupsItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var taskId = taskId_example; // {String} Task ID

var taskRemoveGroupsItem = ; // {TaskRemoveGroupsItem} JSON API response with Groups IDs to remove


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class removeGroupsFromTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var taskId = taskId_example;  // String | Task ID
            var taskRemoveGroupsItem = new TaskRemoveGroupsItem(); // TaskRemoveGroupsItem | JSON API response with Groups IDs to remove

            try
            {
                ResultSuccess result = apiInstance.removeGroupsFromTask(processId, taskId, taskRemoveGroupsItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.removeGroupsFromTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$taskId = taskId_example; // String | Task ID
$taskRemoveGroupsItem = ; // TaskRemoveGroupsItem | JSON API response with Groups IDs to remove

try {
    $result = $api_instance->removeGroupsFromTask($processId, $taskId, $taskRemoveGroupsItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->removeGroupsFromTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modified
        GroupRemoveUsersItem groupRemoveUsersItem = ; // GroupRemoveUsersItem | JSON API response with Users IDs to remove
        try {
            ResultSuccess result = apiInstance.removeUsersFromGroup(id, groupRemoveUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#removeUsersFromGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modified
        GroupRemoveUsersItem groupRemoveUsersItem = ; // GroupRemoveUsersItem | JSON API response with Users IDs to remove
        try {
            ResultSuccess result = apiInstance.removeUsersFromGroup(id, groupRemoveUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#removeUsersFromGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to be modified
GroupRemoveUsersItem *groupRemoveUsersItem = ; // JSON API response with Users IDs to remove

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance removeUsersFromGroupWith:id
    groupRemoveUsersItem:groupRemoveUsersItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to be modified

var groupRemoveUsersItem = ; // {GroupRemoveUsersItem} JSON API response with Users IDs to remove


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class removeUsersFromGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to be modified
            var groupRemoveUsersItem = new GroupRemoveUsersItem(); // GroupRemoveUsersItem | JSON API response with Users IDs to remove

            try
            {
                ResultSuccess result = apiInstance.removeUsersFromGroup(id, groupRemoveUsersItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.removeUsersFromGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to be modified
$groupRemoveUsersItem = ; // GroupRemoveUsersItem | JSON API response with Users IDs to remove

try {
    $result = $api_instance->removeUsersFromGroup($id, $groupRemoveUsersItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->removeUsersFromGroup: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to modify
        TaskSyncGroupsItem taskSyncGroupsItem = ; // TaskSyncGroupsItem | JSON API response with groups IDs to sync
        try {
            ResultSuccess result = apiInstance.syncGroupsToTask(processId, taskId, taskSyncGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#syncGroupsToTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID
        String taskId = taskId_example; // String | ID of task to modify
        TaskSyncGroupsItem taskSyncGroupsItem = ; // TaskSyncGroupsItem | JSON API response with groups IDs to sync
        try {
            ResultSuccess result = apiInstance.syncGroupsToTask(processId, taskId, taskSyncGroupsItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#syncGroupsToTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID
String *taskId = taskId_example; // ID of task to modify
TaskSyncGroupsItem *taskSyncGroupsItem = ; // JSON API response with groups IDs to sync

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance syncGroupsToTaskWith:processId
    taskId:taskId
    taskSyncGroupsItem:taskSyncGroupsItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID

var taskId = taskId_example; // {String} ID of task to modify

var taskSyncGroupsItem = ; // {TaskSyncGroupsItem} JSON API response with groups IDs to sync


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class syncGroupsToTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID
            var taskId = taskId_example;  // String | ID of task to modify
            var taskSyncGroupsItem = new TaskSyncGroupsItem(); // TaskSyncGroupsItem | JSON API response with groups IDs to sync

            try
            {
                ResultSuccess result = apiInstance.syncGroupsToTask(processId, taskId, taskSyncGroupsItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.syncGroupsToTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID
$taskId = taskId_example; // String | ID of task to modify
$taskSyncGroupsItem = ; // TaskSyncGroupsItem | JSON API response with groups IDs to sync

try {
    $result = $api_instance->syncGroupsToTask($processId, $taskId, $taskSyncGroupsItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->syncGroupsToTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modifieded
        GroupSyncUsersItem groupSyncUsersItem = ; // GroupSyncUsersItem | JSON API with array of users IDs to sync
        try {
            ResultSuccess result = apiInstance.syncUsersToGroup(id, groupSyncUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#syncUsersToGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to be modifieded
        GroupSyncUsersItem groupSyncUsersItem = ; // GroupSyncUsersItem | JSON API with array of users IDs to sync
        try {
            ResultSuccess result = apiInstance.syncUsersToGroup(id, groupSyncUsersItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#syncUsersToGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to be modifieded
GroupSyncUsersItem *groupSyncUsersItem = ; // JSON API with array of users IDs to sync

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance syncUsersToGroupWith:id
    groupSyncUsersItem:groupSyncUsersItem
              completionHandler: ^(ResultSuccess output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to be modifieded

var groupSyncUsersItem = ; // {GroupSyncUsersItem} JSON API with array of users IDs to sync


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class syncUsersToGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to be modifieded
            var groupSyncUsersItem = new GroupSyncUsersItem(); // GroupSyncUsersItem | JSON API with array of users IDs to sync

            try
            {
                ResultSuccess result = apiInstance.syncUsersToGroup(id, groupSyncUsersItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.syncUsersToGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to be modifieded
$groupSyncUsersItem = ; // GroupSyncUsersItem | JSON API with array of users IDs to sync

try {
    $result = $api_instance->syncUsersToGroup($id, $groupSyncUsersItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->syncUsersToGroup: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of user to retrieve
        String clientId = clientId_example; // String | ID of client to retrieve
        ClientUpdateItem clientUpdateItem = ; // ClientUpdateItem | Client object to edit
        try {
            ClientItem result = apiInstance.updateClient(userId, clientId, clientUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateClient");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String userId = userId_example; // String | ID of user to retrieve
        String clientId = clientId_example; // String | ID of client to retrieve
        ClientUpdateItem clientUpdateItem = ; // ClientUpdateItem | Client object to edit
        try {
            ClientItem result = apiInstance.updateClient(userId, clientId, clientUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateClient");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *userId = userId_example; // ID of user to retrieve
String *clientId = clientId_example; // ID of client to retrieve
ClientUpdateItem *clientUpdateItem = ; // Client object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateClientWith:userId
    clientId:clientId
    clientUpdateItem:clientUpdateItem
              completionHandler: ^(ClientItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var userId = userId_example; // {String} ID of user to retrieve

var clientId = clientId_example; // {String} ID of client to retrieve

var clientUpdateItem = ; // {ClientUpdateItem} Client object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateClientExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var userId = userId_example;  // String | ID of user to retrieve
            var clientId = clientId_example;  // String | ID of client to retrieve
            var clientUpdateItem = new ClientUpdateItem(); // ClientUpdateItem | Client object to edit

            try
            {
                ClientItem result = apiInstance.updateClient(userId, clientId, clientUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateClient: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$userId = userId_example; // String | ID of user to retrieve
$clientId = clientId_example; // String | ID of client to retrieve
$clientUpdateItem = ; // ClientUpdateItem | Client object to edit

try {
    $result = $api_instance->updateClient($userId, $clientId, $clientUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateClient: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String eventId = eventId_example; // String | ID of event to retrieve
        EventUpdateItem eventUpdateItem = ; // EventUpdateItem | Event object to edit
        try {
            EventItem result = apiInstance.updateEvent(processId, eventId, eventUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateEvent");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String eventId = eventId_example; // String | ID of event to retrieve
        EventUpdateItem eventUpdateItem = ; // EventUpdateItem | Event object to edit
        try {
            EventItem result = apiInstance.updateEvent(processId, eventId, eventUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateEvent");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to retrieve
String *eventId = eventId_example; // ID of event to retrieve
EventUpdateItem *eventUpdateItem = ; // Event object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateEventWith:processId
    eventId:eventId
    eventUpdateItem:eventUpdateItem
              completionHandler: ^(EventItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to retrieve

var eventId = eventId_example; // {String} ID of event to retrieve

var eventUpdateItem = ; // {EventUpdateItem} Event object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateEventExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to retrieve
            var eventId = eventId_example;  // String | ID of event to retrieve
            var eventUpdateItem = new EventUpdateItem(); // EventUpdateItem | Event object to edit

            try
            {
                EventItem result = apiInstance.updateEvent(processId, eventId, eventUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateEvent: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to retrieve
$eventId = eventId_example; // String | ID of event to retrieve
$eventUpdateItem = ; // EventUpdateItem | Event object to edit

try {
    $result = $api_instance->updateEvent($processId, $eventId, $eventUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateEvent: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        String connectorId = connectorId_example; // String | ID of Event Connector to fetch
        EventConnectorUpdateItem eventConnectorUpdateItem = ; // EventConnectorUpdateItem | EventConnector object to edit
        try {
            EventConnector_1 result = apiInstance.updateEventConnector(processId, eventId, connectorId, eventConnectorUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String eventId = eventId_example; // String | ID of Event to fetch
        String connectorId = connectorId_example; // String | ID of Event Connector to fetch
        EventConnectorUpdateItem eventConnectorUpdateItem = ; // EventConnectorUpdateItem | EventConnector object to edit
        try {
            EventConnector_1 result = apiInstance.updateEventConnector(processId, eventId, connectorId, eventConnectorUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateEventConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *eventId = eventId_example; // ID of Event to fetch
String *connectorId = connectorId_example; // ID of Event Connector to fetch
EventConnectorUpdateItem *eventConnectorUpdateItem = ; // EventConnector object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateEventConnectorWith:processId
    eventId:eventId
    connectorId:connectorId
    eventConnectorUpdateItem:eventConnectorUpdateItem
              completionHandler: ^(EventConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var eventId = eventId_example; // {String} ID of Event to fetch

var connectorId = connectorId_example; // {String} ID of Event Connector to fetch

var eventConnectorUpdateItem = ; // {EventConnectorUpdateItem} EventConnector object to edit


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateEventConnector(processId, eventId, connectorId, eventConnectorUpdateItem, callback);

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateEventConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var eventId = eventId_example;  // String | ID of Event to fetch
            var connectorId = connectorId_example;  // String | ID of Event Connector to fetch
            var eventConnectorUpdateItem = new EventConnectorUpdateItem(); // EventConnectorUpdateItem | EventConnector object to edit

            try
            {
                EventConnector_1 result = apiInstance.updateEventConnector(processId, eventId, connectorId, eventConnectorUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateEventConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$eventId = eventId_example; // String | ID of Event to fetch
$connectorId = connectorId_example; // String | ID of Event Connector to fetch
$eventConnectorUpdateItem = ; // EventConnectorUpdateItem | EventConnector object to edit

try {
    $result = $api_instance->updateEventConnector($processId, $eventId, $connectorId, $eventConnectorUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateEventConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String flowId = flowId_example; // String | ID of flow to retrieve
        FlowUpdateItem flowUpdateItem = ; // FlowUpdateItem | Flow object to edit
        try {
            FlowItem result = apiInstance.updateFlow(processId, flowId, flowUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateFlow");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String flowId = flowId_example; // String | ID of flow to retrieve
        FlowUpdateItem flowUpdateItem = ; // FlowUpdateItem | Flow object to edit
        try {
            FlowItem result = apiInstance.updateFlow(processId, flowId, flowUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateFlow");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to retrieve
String *flowId = flowId_example; // ID of flow to retrieve
FlowUpdateItem *flowUpdateItem = ; // Flow object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateFlowWith:processId
    flowId:flowId
    flowUpdateItem:flowUpdateItem
              completionHandler: ^(FlowItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to retrieve

var flowId = flowId_example; // {String} ID of flow to retrieve

var flowUpdateItem = ; // {FlowUpdateItem} Flow object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateFlowExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to retrieve
            var flowId = flowId_example;  // String | ID of flow to retrieve
            var flowUpdateItem = new FlowUpdateItem(); // FlowUpdateItem | Flow object to edit

            try
            {
                FlowItem result = apiInstance.updateFlow(processId, flowId, flowUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateFlow: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to retrieve
$flowId = flowId_example; // String | ID of flow to retrieve
$flowUpdateItem = ; // FlowUpdateItem | Flow object to edit

try {
    $result = $api_instance->updateFlow($processId, $flowId, $flowUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateFlow: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String gatewayId = gatewayId_example; // String | ID of gateway to retrieve
        GatewayUpdateItem gatewayUpdateItem = ; // GatewayUpdateItem | Gateway object to edit
        try {
            GatewayItem result = apiInstance.updateGateway(processId, gatewayId, gatewayUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateGateway");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of process to retrieve
        String gatewayId = gatewayId_example; // String | ID of gateway to retrieve
        GatewayUpdateItem gatewayUpdateItem = ; // GatewayUpdateItem | Gateway object to edit
        try {
            GatewayItem result = apiInstance.updateGateway(processId, gatewayId, gatewayUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateGateway");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of process to retrieve
String *gatewayId = gatewayId_example; // ID of gateway to retrieve
GatewayUpdateItem *gatewayUpdateItem = ; // Gateway object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateGatewayWith:processId
    gatewayId:gatewayId
    gatewayUpdateItem:gatewayUpdateItem
              completionHandler: ^(GatewayItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of process to retrieve

var gatewayId = gatewayId_example; // {String} ID of gateway to retrieve

var gatewayUpdateItem = ; // {GatewayUpdateItem} Gateway object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateGatewayExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of process to retrieve
            var gatewayId = gatewayId_example;  // String | ID of gateway to retrieve
            var gatewayUpdateItem = new GatewayUpdateItem(); // GatewayUpdateItem | Gateway object to edit

            try
            {
                GatewayItem result = apiInstance.updateGateway(processId, gatewayId, gatewayUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateGateway: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of process to retrieve
$gatewayId = gatewayId_example; // String | ID of gateway to retrieve
$gatewayUpdateItem = ; // GatewayUpdateItem | Gateway object to edit

try {
    $result = $api_instance->updateGateway($processId, $gatewayId, $gatewayUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateGateway: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to retrieve
        GroupUpdateItem groupUpdateItem = ; // GroupUpdateItem | Group object to edit
        try {
            GroupItem result = apiInstance.updateGroup(id, groupUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateGroup");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of group to retrieve
        GroupUpdateItem groupUpdateItem = ; // GroupUpdateItem | Group object to edit
        try {
            GroupItem result = apiInstance.updateGroup(id, groupUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateGroup");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of group to retrieve
GroupUpdateItem *groupUpdateItem = ; // Group object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateGroupWith:id
    groupUpdateItem:groupUpdateItem
              completionHandler: ^(GroupItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of group to retrieve

var groupUpdateItem = ; // {GroupUpdateItem} Group object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateGroupExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of group to retrieve
            var groupUpdateItem = new GroupUpdateItem(); // GroupUpdateItem | Group object to edit

            try
            {
                GroupItem result = apiInstance.updateGroup(id, groupUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateGroup: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of group to retrieve
$groupUpdateItem = ; // GroupUpdateItem | Group object to edit

try {
    $result = $api_instance->updateGroup($id, $groupUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateGroup: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to the Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to retrieve
        InputOutputUpdateItem inputOutputUpdateItem = ; // InputOutputUpdateItem | Input/Output object to edit
        try {
            InputOutputItem result = apiInstance.updateInputOutput(processId, taskId, inputoutputUid, inputOutputUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | Process ID related to the Input/Output object
        String taskId = taskId_example; // String | Task instance ID related to the Input/Output object
        String inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to retrieve
        InputOutputUpdateItem inputOutputUpdateItem = ; // InputOutputUpdateItem | Input/Output object to edit
        try {
            InputOutputItem result = apiInstance.updateInputOutput(processId, taskId, inputoutputUid, inputOutputUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateInputOutput");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // Process ID related to the Input/Output object
String *taskId = taskId_example; // Task instance ID related to the Input/Output object
String *inputoutputUid = inputoutputUid_example; // ID of Input/Output to retrieve
InputOutputUpdateItem *inputOutputUpdateItem = ; // Input/Output object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateInputOutputWith:processId
    taskId:taskId
    inputoutputUid:inputoutputUid
    inputOutputUpdateItem:inputOutputUpdateItem
              completionHandler: ^(InputOutputItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} Process ID related to the Input/Output object

var taskId = taskId_example; // {String} Task instance ID related to the Input/Output object

var inputoutputUid = inputoutputUid_example; // {String} ID of Input/Output to retrieve

var inputOutputUpdateItem = ; // {InputOutputUpdateItem} Input/Output object to edit


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateInputOutput(processId, taskId, inputoutputUid, inputOutputUpdateItem, callback);

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateInputOutputExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | Process ID related to the Input/Output object
            var taskId = taskId_example;  // String | Task instance ID related to the Input/Output object
            var inputoutputUid = inputoutputUid_example;  // String | ID of Input/Output to retrieve
            var inputOutputUpdateItem = new InputOutputUpdateItem(); // InputOutputUpdateItem | Input/Output object to edit

            try
            {
                InputOutputItem result = apiInstance.updateInputOutput(processId, taskId, inputoutputUid, inputOutputUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateInputOutput: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | Process ID related to the Input/Output object
$taskId = taskId_example; // String | Task instance ID related to the Input/Output object
$inputoutputUid = inputoutputUid_example; // String | ID of Input/Output to retrieve
$inputOutputUpdateItem = ; // InputOutputUpdateItem | Input/Output object to edit

try {
    $result = $api_instance->updateInputOutput($processId, $taskId, $inputoutputUid, $inputOutputUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateInputOutput: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to retrieve
        String instanceId = instanceId_example; // String | ID of Instance to retrieve
        InstanceUpdateItem instanceUpdateItem = ; // InstanceUpdateItem | Instance object to edit
        try {
            InstanceItem result = apiInstance.updateInstance(processId, instanceId, instanceUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateInstance");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to retrieve
        String instanceId = instanceId_example; // String | ID of Instance to retrieve
        InstanceUpdateItem instanceUpdateItem = ; // InstanceUpdateItem | Instance object to edit
        try {
            InstanceItem result = apiInstance.updateInstance(processId, instanceId, instanceUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateInstance");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to retrieve
String *instanceId = instanceId_example; // ID of Instance to retrieve
InstanceUpdateItem *instanceUpdateItem = ; // Instance object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateInstanceWith:processId
    instanceId:instanceId
    instanceUpdateItem:instanceUpdateItem
              completionHandler: ^(InstanceItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to retrieve

var instanceId = instanceId_example; // {String} ID of Instance to retrieve

var instanceUpdateItem = ; // {InstanceUpdateItem} Instance object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateInstanceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to retrieve
            var instanceId = instanceId_example;  // String | ID of Instance to retrieve
            var instanceUpdateItem = new InstanceUpdateItem(); // InstanceUpdateItem | Instance object to edit

            try
            {
                InstanceItem result = apiInstance.updateInstance(processId, instanceId, instanceUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateInstance: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to retrieve
$instanceId = instanceId_example; // String | ID of Instance to retrieve
$instanceUpdateItem = ; // InstanceUpdateItem | Instance object to edit

try {
    $result = $api_instance->updateInstance($processId, $instanceId, $instanceUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateInstance: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of process to retrieve
        ProcessUpdateItem processUpdateItem = ; // ProcessUpdateItem | Process object to edit
        try {
            ProcessItem result = apiInstance.updateProcess(id, processUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateProcess");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of process to retrieve
        ProcessUpdateItem processUpdateItem = ; // ProcessUpdateItem | Process object to edit
        try {
            ProcessItem result = apiInstance.updateProcess(id, processUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateProcess");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of process to retrieve
ProcessUpdateItem *processUpdateItem = ; // Process object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateProcessWith:id
    processUpdateItem:processUpdateItem
              completionHandler: ^(ProcessItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of process to retrieve

var processUpdateItem = ; // {ProcessUpdateItem} Process object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateProcessExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of process to retrieve
            var processUpdateItem = new ProcessUpdateItem(); // ProcessUpdateItem | Process object to edit

            try
            {
                ProcessItem result = apiInstance.updateProcess(id, processUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateProcess: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of process to retrieve
$processUpdateItem = ; // ProcessUpdateItem | Process object to edit

try {
    $result = $api_instance->updateProcess($id, $processUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateProcess: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        TaskUpdateItem taskUpdateItem = ; // TaskUpdateItem | Task object to edit
        try {
            TaskItem result = apiInstance.updateTask(processId, taskId, taskUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTask");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        TaskUpdateItem taskUpdateItem = ; // TaskUpdateItem | Task object to edit
        try {
            TaskItem result = apiInstance.updateTask(processId, taskId, taskUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTask");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *taskId = taskId_example; // ID of Task to fetch
TaskUpdateItem *taskUpdateItem = ; // Task object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateTaskWith:processId
    taskId:taskId
    taskUpdateItem:taskUpdateItem
              completionHandler: ^(TaskItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var taskId = taskId_example; // {String} ID of Task to fetch

var taskUpdateItem = ; // {TaskUpdateItem} Task object to edit


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var taskId = taskId_example;  // String | ID of Task to fetch
            var taskUpdateItem = new TaskUpdateItem(); // TaskUpdateItem | Task object to edit

            try
            {
                TaskItem result = apiInstance.updateTask(processId, taskId, taskUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateTask: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$taskId = taskId_example; // String | ID of Task to fetch
$taskUpdateItem = ; // TaskUpdateItem | Task object to edit

try {
    $result = $api_instance->updateTask($processId, $taskId, $taskUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateTask: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        String connectorId = connectorId_example; // String | ID of Task Connector to fetch
        TaskConnectorUpdateItem taskConnectorUpdateItem = ; // TaskConnectorUpdateItem | TaskConnector object to edit
        try {
            TaskConnector_1 result = apiInstance.updateTaskConnector(processId, taskId, connectorId, taskConnectorUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String processId = processId_example; // String | ID of Process to fetch
        String taskId = taskId_example; // String | ID of Task to fetch
        String connectorId = connectorId_example; // String | ID of Task Connector to fetch
        TaskConnectorUpdateItem taskConnectorUpdateItem = ; // TaskConnectorUpdateItem | TaskConnector object to edit
        try {
            TaskConnector_1 result = apiInstance.updateTaskConnector(processId, taskId, connectorId, taskConnectorUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTaskConnector");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *processId = processId_example; // ID of Process to fetch
String *taskId = taskId_example; // ID of Task to fetch
String *connectorId = connectorId_example; // ID of Task Connector to fetch
TaskConnectorUpdateItem *taskConnectorUpdateItem = ; // TaskConnector object to edit

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateTaskConnectorWith:processId
    taskId:taskId
    connectorId:connectorId
    taskConnectorUpdateItem:taskConnectorUpdateItem
              completionHandler: ^(TaskConnector_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var processId = processId_example; // {String} ID of Process to fetch

var taskId = taskId_example; // {String} ID of Task to fetch

var connectorId = connectorId_example; // {String} ID of Task Connector to fetch

var taskConnectorUpdateItem = ; // {TaskConnectorUpdateItem} TaskConnector object to edit


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateTaskConnector(processId, taskId, connectorId, taskConnectorUpdateItem, callback);

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateTaskConnectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var processId = processId_example;  // String | ID of Process to fetch
            var taskId = taskId_example;  // String | ID of Task to fetch
            var connectorId = connectorId_example;  // String | ID of Task Connector to fetch
            var taskConnectorUpdateItem = new TaskConnectorUpdateItem(); // TaskConnectorUpdateItem | TaskConnector object to edit

            try
            {
                TaskConnector_1 result = apiInstance.updateTaskConnector(processId, taskId, connectorId, taskConnectorUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateTaskConnector: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$processId = processId_example; // String | ID of Process to fetch
$taskId = taskId_example; // String | ID of Task to fetch
$connectorId = connectorId_example; // String | ID of Task Connector to fetch
$taskConnectorUpdateItem = ; // TaskConnectorUpdateItem | TaskConnector object to edit

try {
    $result = $api_instance->updateTaskConnector($processId, $taskId, $connectorId, $taskConnectorUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateTaskConnector: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String taskInstanceId = taskInstanceId_example; // String | ID of task instance to retrieve
        TaskInstanceUpdateItem taskInstanceUpdateItem = ; // TaskInstanceUpdateItem | Task Instance object to update
        try {
            inline_response_200 result = apiInstance.updateTaskInstance(taskInstanceId, taskInstanceUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTaskInstance");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String taskInstanceId = taskInstanceId_example; // String | ID of task instance to retrieve
        TaskInstanceUpdateItem taskInstanceUpdateItem = ; // TaskInstanceUpdateItem | Task Instance object to update
        try {
            inline_response_200 result = apiInstance.updateTaskInstance(taskInstanceId, taskInstanceUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateTaskInstance");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *taskInstanceId = taskInstanceId_example; // ID of task instance to retrieve
TaskInstanceUpdateItem *taskInstanceUpdateItem = ; // Task Instance object to update

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateTaskInstanceWith:taskInstanceId
    taskInstanceUpdateItem:taskInstanceUpdateItem
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var taskInstanceId = taskInstanceId_example; // {String} ID of task instance to retrieve

var taskInstanceUpdateItem = ; // {TaskInstanceUpdateItem} Task Instance object to update


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateTaskInstanceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var taskInstanceId = taskInstanceId_example;  // String | ID of task instance to retrieve
            var taskInstanceUpdateItem = new TaskInstanceUpdateItem(); // TaskInstanceUpdateItem | Task Instance object to update

            try
            {
                inline_response_200 result = apiInstance.updateTaskInstance(taskInstanceId, taskInstanceUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateTaskInstance: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$taskInstanceId = taskInstanceId_example; // String | ID of task instance to retrieve
$taskInstanceUpdateItem = ; // TaskInstanceUpdateItem | Task Instance object to update

try {
    $result = $api_instance->updateTaskInstance($taskInstanceId, $taskInstanceUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateTaskInstance: ', $e->getMessage(), PHP_EOL;
}

                                                  

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import .ProcessmakerApi;

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

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: PasswordGrant
        OAuth PasswordGrant = (OAuth) defaultClient.getAuthentication("PasswordGrant");
        PasswordGrant.setAccessToken("YOUR ACCESS TOKEN");

        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of user to retrieve
        UserUpdateItem userUpdateItem = ; // UserUpdateItem | User object for update
        try {
            UserItem result = apiInstance.updateUser(id, userUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateUser");
            e.printStackTrace();
        }
    }
}

                                                  

import .ProcessmakerApi;

public class ProcessmakerApiExample {

    public static void main(String[] args) {
        ProcessmakerApi apiInstance = new ProcessmakerApi();
        String id = id_example; // String | ID of user to retrieve
        UserUpdateItem userUpdateItem = ; // UserUpdateItem | User object for update
        try {
            UserItem result = apiInstance.updateUser(id, userUpdateItem);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessmakerApi#updateUser");
            e.printStackTrace();
        }
    }
}

                                                  

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: PasswordGrant)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


String *id = id_example; // ID of user to retrieve
UserUpdateItem *userUpdateItem = ; // User object for update

ProcessmakerApi *apiInstance = [[ProcessmakerApi alloc] init];

[apiInstance updateUserWith:id
    userUpdateItem:userUpdateItem
              completionHandler: ^(UserItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

                                                    

var  = require('');
var defaultClient = .ApiClient.instance;

// Configure OAuth2 access token for authorization: PasswordGrant
var PasswordGrant = defaultClient.authentications['PasswordGrant'];
PasswordGrant.accessToken = "YOUR ACCESS TOKEN"

var api = new .ProcessmakerApi()

var id = id_example; // {String} ID of user to retrieve

var userUpdateItem = ; // {UserUpdateItem} User object for update


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

                                                    

using System;
using System.Diagnostics;
using .Api;
using .Client;
using ;

namespace Example
{
    public class updateUserExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: PasswordGrant
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ProcessmakerApi();
            var id = id_example;  // String | ID of user to retrieve
            var userUpdateItem = new UserUpdateItem(); // UserUpdateItem | User object for update

            try
            {
                UserItem result = apiInstance.updateUser(id, userUpdateItem);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessmakerApi.updateUser: " + e.Message );
            }
        }
    }
}

                                                    

setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new io.swagger.client\Api\ProcessmakerApi();
$id = id_example; // String | ID of user to retrieve
$userUpdateItem = ; // UserUpdateItem | User object for update

try {
    $result = $api_instance->updateUser($id, $userUpdateItem);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessmakerApi->updateUser: ', $e->getMessage(), PHP_EOL;
}