import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccessApi;

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

public class AccessApiExample {

    public static void main(String[] args) {
        
        AccessApi apiInstance = new AccessApi();
        try {
            CurrentUser result = apiInstance.getAccessStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getAccessStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccessApi;

public class AccessApiExample {

    public static void main(String[] args) {
        AccessApi apiInstance = new AccessApi();
        try {
            CurrentUser result = apiInstance.getAccessStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getAccessStatus");
            e.printStackTrace();
        }
    }
}

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

// Returns the current client's authenticated identity. [BETA]
[apiInstance getAccessStatusWithCompletionHandler: 
              ^(CurrentUser output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AccessApi();

            try
            {
                // Returns the current client's authenticated identity. [BETA]
                CurrentUser result = apiInstance.getAccessStatus();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getAccessStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccessApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccessApi;

my $api_instance = WWW::SwaggerClient::AccessApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.AccessApi()

try: 
    # Returns the current client's authenticated identity. [BETA]
    api_response = api_instance.get_access_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getAccessStatus: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The class to create
        try {
            AgentClass result = apiInstance.createAgentClass(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#createAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The class to create
        try {
            AgentClass result = apiInstance.createAgentClass(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#createAgentClass");
            e.printStackTrace();
        }
    }
}

AgentClass *body = ; // The class to create

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

// Register a MiNiFi agent class with this C2 server
[apiInstance createAgentClassWith:body
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var body = ; // {{AgentClass}} The class to create

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();
            var body = new AgentClass(); // AgentClass | The class to create

            try
            {
                // Register a MiNiFi agent class with this C2 server
                AgentClass result = apiInstance.createAgentClass(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.createAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$body = ; // AgentClass | The class to create

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentClassesApi;

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $body = WWW::SwaggerClient::Object::AgentClass->new(); # AgentClass | The class to create

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
body =  # AgentClass | The class to create

try: 
    # Register a MiNiFi agent class with this C2 server
    api_response = api_instance.create_agent_class(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->createAgentClass: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to delete
        try {
            AgentClass result = apiInstance.deleteAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#deleteAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to delete
        try {
            AgentClass result = apiInstance.deleteAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#deleteAgentClass");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // The name of the class to delete

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

// Delete a MiNiFi agent class
[apiInstance deleteAgentClassWith:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var name = name_example; // {{String}} The name of the class to delete

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();
            var name = name_example;  // String | The name of the class to delete

            try
            {
                // Delete a MiNiFi agent class
                AgentClass result = apiInstance.deleteAgentClass(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.deleteAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$name = name_example; // String | The name of the class to delete

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentClassesApi;

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $name = name_example; # String | The name of the class to delete

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
name = name_example # String | The name of the class to delete

try: 
    # Delete a MiNiFi agent class
    api_response = api_instance.delete_agent_class(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->deleteAgentClass: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to retrieve
        try {
            AgentClass result = apiInstance.getAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to retrieve
        try {
            AgentClass result = apiInstance.getAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClass");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // The name of the class to retrieve

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

// Get a MiNiFi agent class that is registered with this C2 server
[apiInstance getAgentClassWith:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var name = name_example; // {{String}} The name of the class to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();
            var name = name_example;  // String | The name of the class to retrieve

            try
            {
                // Get a MiNiFi agent class that is registered with this C2 server
                AgentClass result = apiInstance.getAgentClass(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$name = name_example; // String | The name of the class to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentClassesApi;

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $name = name_example; # String | The name of the class to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
name = name_example # String | The name of the class to retrieve

try: 
    # Get a MiNiFi agent class that is registered with this C2 server
    api_response = api_instance.get_agent_class(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getAgentClass: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        try {
            array[AgentClass] result = apiInstance.getAgentClasses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClasses");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        try {
            array[AgentClass] result = apiInstance.getAgentClasses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClasses");
            e.printStackTrace();
        }
    }
}

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

// Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
[apiInstance getAgentClassesWithCompletionHandler: 
              ^(array[AgentClass] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();

            try
            {
                // Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
                array[AgentClass] result = apiInstance.getAgentClasses();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getAgentClasses: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassesApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentClassesApi;

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()

try: 
    # Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
    api_response = api_instance.get_agent_classes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getAgentClasses: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The metadata of the class to associate with the given name.
        String name = name_example; // String | The name of the class
        try {
            AgentClass result = apiInstance.replaceAgentClass(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#replaceAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The metadata of the class to associate with the given name.
        String name = name_example; // String | The name of the class
        try {
            AgentClass result = apiInstance.replaceAgentClass(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#replaceAgentClass");
            e.printStackTrace();
        }
    }
}

AgentClass *body = ; // The metadata of the class to associate with the given name.
String *name = name_example; // The name of the class

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

// Update a MiNiFi agent class by replacing it in full
[apiInstance replaceAgentClassWith:body
    name:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var body = ; // {{AgentClass}} The metadata of the class to associate with the given name.
var name = name_example; // {{String}} The name of the class

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();
            var body = new AgentClass(); // AgentClass | The metadata of the class to associate with the given name.
            var name = name_example;  // String | The name of the class

            try
            {
                // Update a MiNiFi agent class by replacing it in full
                AgentClass result = apiInstance.replaceAgentClass(body, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.replaceAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$body = ; // AgentClass | The metadata of the class to associate with the given name.
$name = name_example; // String | The name of the class

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentClassesApi;

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $body = WWW::SwaggerClient::Object::AgentClass->new(); # AgentClass | The metadata of the class to associate with the given name.
my $name = name_example; # String | The name of the class

eval { 
    my $result = $api_instance->replaceAgentClass(body => $body, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassesApi->replaceAgentClass: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
body =  # AgentClass | The metadata of the class to associate with the given name.
name = name_example # String | The name of the class

try: 
    # Update a MiNiFi agent class by replacing it in full
    api_response = api_instance.replace_agent_class(body, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->replaceAgentClass: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        AgentManifest body = ; // AgentManifest | 
        String class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded
        try {
            AgentManifest result = apiInstance.createAgentManifest(body, class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#createAgentManifest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        AgentManifest body = ; // AgentManifest | 
        String class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded
        try {
            AgentManifest result = apiInstance.createAgentManifest(body, class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#createAgentManifest");
            e.printStackTrace();
        }
    }
}

AgentManifest *body = ; //  (optional)
String *class = class_example; // Optionally, a class label to associate with the manifest being uploaded (optional)

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

// Upload an agent manifest
[apiInstance createAgentManifestWith:body
    class:class
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var opts = { 
  'body':  // {{AgentManifest}} 
  'class': class_example // {{String}} Optionally, a class label to associate with the manifest being uploaded
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgentManifest(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var body = new AgentManifest(); // AgentManifest |  (optional) 
            var class = class_example;  // String | Optionally, a class label to associate with the manifest being uploaded (optional) 

            try
            {
                // Upload an agent manifest
                AgentManifest result = apiInstance.createAgentManifest(body, class);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.createAgentManifest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$body = ; // AgentManifest | 
$class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentManifestsApi;

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $body = WWW::SwaggerClient::Object::AgentManifest->new(); # AgentManifest | 
my $class = class_example; # String | Optionally, a class label to associate with the manifest being uploaded

eval { 
    my $result = $api_instance->createAgentManifest(body => $body, class => $class);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManifestsApi->createAgentManifest: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
body =  # AgentManifest |  (optional)
class = class_example # String | Optionally, a class label to associate with the manifest being uploaded (optional)

try: 
    # Upload an agent manifest
    api_response = api_instance.create_agent_manifest(body=body, class=class)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->createAgentManifest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.deleteAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#deleteAgentManifest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.deleteAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#deleteAgentManifest");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 

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

// Delete the agent manifest specified by id
[apiInstance deleteAgentManifestWith:id
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var id = id_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var id = id_example;  // String | 

            try
            {
                // Delete the agent manifest specified by id
                AgentManifest result = apiInstance.deleteAgentManifest(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.deleteAgentManifest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$id = id_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentManifestsApi;

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $id = id_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
id = id_example # String | 

try: 
    # Delete the agent manifest specified by id
    api_response = api_instance.delete_agent_manifest(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->deleteAgentManifest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.getAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.getAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifest");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 

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

// Get the agent manifest specified by the id
[apiInstance getAgentManifestWith:id
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var id = id_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var id = id_example;  // String | 

            try
            {
                // Get the agent manifest specified by the id
                AgentManifest result = apiInstance.getAgentManifest(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.getAgentManifest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$id = id_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentManifestsApi;

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $id = id_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
id = id_example # String | 

try: 
    # Get the agent manifest specified by the id
    api_response = api_instance.get_agent_manifest(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->getAgentManifest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String class = class_example; // String | Optionally, filter the results to match a class label
        try {
            array[AgentManifest] result = apiInstance.getAgentManifests(class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifests");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String class = class_example; // String | Optionally, filter the results to match a class label
        try {
            array[AgentManifest] result = apiInstance.getAgentManifests(class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifests");
            e.printStackTrace();
        }
    }
}

String *class = class_example; // Optionally, filter the results to match a class label (optional)

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

// Get all agent manifests. [BETA]
[apiInstance getAgentManifestsWith:class
              completionHandler: ^(array[AgentManifest] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var opts = { 
  'class': class_example // {{String}} Optionally, filter the results to match a class label
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentManifests(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var class = class_example;  // String | Optionally, filter the results to match a class label (optional) 

            try
            {
                // Get all agent manifests. [BETA]
                array[AgentManifest] result = apiInstance.getAgentManifests(class);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.getAgentManifests: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$class = class_example; // String | Optionally, filter the results to match a class label

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentManifestsApi;

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $class = class_example; # String | Optionally, filter the results to match a class label

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

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
class = class_example # String | Optionally, filter the results to match a class label (optional)

try: 
    # Get all agent manifests. [BETA]
    api_response = api_instance.get_agent_manifests(class=class)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->getAgentManifests: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        AgentInfo body = ; // AgentInfo | The metadata of the agent to register
        try {
            AgentInfo result = apiInstance.createAgent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        AgentInfo body = ; // AgentInfo | The metadata of the agent to register
        try {
            AgentInfo result = apiInstance.createAgent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgent");
            e.printStackTrace();
        }
    }
}

AgentInfo *body = ; // The metadata of the agent to register (optional)

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

// Register a MiNiFi agent with this C2 server
[apiInstance createAgentWith:body
              completionHandler: ^(AgentInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var opts = { 
  'body':  // {{AgentInfo}} The metadata of the agent to register
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgent(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var body = new AgentInfo(); // AgentInfo | The metadata of the agent to register (optional) 

            try
            {
                // Register a MiNiFi agent with this C2 server
                AgentInfo result = apiInstance.createAgent(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.createAgent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$body = ; // AgentInfo | The metadata of the agent to register

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $body = WWW::SwaggerClient::Object::AgentInfo->new(); # AgentInfo | The metadata of the agent to register

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
body =  # AgentInfo | The metadata of the agent to register (optional)

try: 
    # Register a MiNiFi agent with this C2 server
    api_response = api_instance.create_agent(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->createAgent: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the agent to provide parameters for
array[Parameter] *body = ; // The metadata of the agent to register (optional)

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

// Register a set of Parameters to use with this agent.
[apiInstance createAgentParametersWith:id
    body:body
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to provide parameters for
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the agent to register
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgentParameters(id, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to provide parameters for
            var body = new array[Parameter](); // array[Parameter] | The metadata of the agent to register (optional) 

            try
            {
                // Register a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.createAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.createAgentParameters: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to provide parameters for
$body = ; // array[Parameter] | The metadata of the agent to register

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to provide parameters for
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to register

eval { 
    my $result = $api_instance->createAgentParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->createAgentParameters: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to provide parameters for
body =  # array[Parameter] | The metadata of the agent to register (optional)

try: 
    # Register a set of Parameters to use with this agent.
    api_response = api_instance.create_agent_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->createAgentParameters: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to delete
        try {
            Agent result = apiInstance.deleteAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to delete
        try {
            Agent result = apiInstance.deleteAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgent");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the agent to delete

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

// Delete an agent registered with this C2 server
[apiInstance deleteAgentWith:id
              completionHandler: ^(Agent output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to delete

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to delete

            try
            {
                // Delete an agent registered with this C2 server
                Agent result = apiInstance.deleteAgent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.deleteAgent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to delete

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to delete

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to delete

try: 
    # Delete an agent registered with this C2 server
    api_response = api_instance.delete_agent(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->deleteAgent: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String agentId = agentId_example; // String | The identifier of the agent to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgentParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String agentId = agentId_example; // String | The identifier of the agent to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgentParameters");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // The identifier of the agent to delete its parameter context

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

// Delete an instance specific parameter context
[apiInstance deleteAgentParametersWith:agentId
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var agentId = agentId_example; // {{String}} The identifier of the agent to delete its parameter context

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var agentId = agentId_example;  // String | The identifier of the agent to delete its parameter context

            try
            {
                // Delete an instance specific parameter context
                ParameterContext result = apiInstance.deleteAgentParameters(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.deleteAgentParameters: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$agentId = agentId_example; // String | The identifier of the agent to delete its parameter context

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $agentId = agentId_example; # String | The identifier of the agent to delete its parameter context

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
agentId = agentId_example # String | The identifier of the agent to delete its parameter context

try: 
    # Delete an instance specific parameter context
    api_response = api_instance.delete_agent_parameters(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->deleteAgentParameters: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve
        try {
            Agent result = apiInstance.getAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve
        try {
            Agent result = apiInstance.getAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgent");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the agent to retrieve

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

// Retrieve info for a MiNiFi agent registered with this C2 server
[apiInstance getAgentWith:id
              completionHandler: ^(Agent output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to retrieve

            try
            {
                // Retrieve info for a MiNiFi agent registered with this C2 server
                Agent result = apiInstance.getAgent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to retrieve

try: 
    # Retrieve info for a MiNiFi agent registered with this C2 server
    api_response = api_instance.get_agent(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgent: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve parameters for
        try {
            ParameterContext result = apiInstance.getAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve parameters for
        try {
            ParameterContext result = apiInstance.getAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentParameters");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the agent to retrieve parameters for

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

// Retrieve the parameter context for a MiNiFi agent with the specified id
[apiInstance getAgentParametersWith:id
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to retrieve parameters for

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to retrieve parameters for

            try
            {
                // Retrieve the parameter context for a MiNiFi agent with the specified id
                ParameterContext result = apiInstance.getAgentParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgentParameters: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to retrieve parameters for

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to retrieve parameters for

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to retrieve parameters for

try: 
    # Retrieve the parameter context for a MiNiFi agent with the specified id
    api_response = api_instance.get_agent_parameters(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgentParameters: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        try {
            array[Agent] result = apiInstance.getAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        try {
            array[Agent] result = apiInstance.getAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgents");
            e.printStackTrace();
        }
    }
}

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

// Get all MiNiFi agents known to this C2 Server. [BETA]
[apiInstance getAgentsWithCompletionHandler: 
              ^(array[Agent] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();

            try
            {
                // Get all MiNiFi agents known to this C2 Server. [BETA]
                array[Agent] result = apiInstance.getAgents();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentsApi;

my $api_instance = WWW::SwaggerClient::AgentsApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()

try: 
    # Get all MiNiFi agents known to this C2 Server. [BETA]
    api_response = api_instance.get_agents()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgents: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ConfigurationApi;

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

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getC2ConfigurationInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ConfigurationApi;

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getC2ConfigurationInfo");
            e.printStackTrace();
        }
    }
}

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

// Get general information about the configuration of the C2 server
[apiInstance getC2ConfigurationInfoWithCompletionHandler: 
              ^(C2ConfigurationInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ConfigurationApi();

            try
            {
                // Get general information about the configuration of the C2 server
                C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ConfigurationApi.getC2ConfigurationInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ConfigurationApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::C2ConfigurationApi;

my $api_instance = WWW::SwaggerClient::C2ConfigurationApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.C2ConfigurationApi()

try: 
    # Get general information about the configuration of the C2 server
    api_response = api_instance.get_c2_configuration_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ConfigurationApi->getC2ConfigurationInfo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ConfigurationApi;

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

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getNiFiRegistryInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ConfigurationApi;

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getNiFiRegistryInfo");
            e.printStackTrace();
        }
    }
}

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

// Get information about the NiFi Registry that the C2 server is configured with
[apiInstance getNiFiRegistryInfoWithCompletionHandler: 
              ^(NiFiRegistryInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ConfigurationApi();

            try
            {
                // Get information about the NiFi Registry that the C2 server is configured with
                NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ConfigurationApi.getNiFiRegistryInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ConfigurationApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::C2ConfigurationApi;

my $api_instance = WWW::SwaggerClient::C2ConfigurationApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.C2ConfigurationApi()

try: 
    # Get information about the NiFi Registry that the C2 server is configured with
    api_response = api_instance.get_ni_fi_registry_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ConfigurationApi->getNiFiRegistryInfo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolApi;

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

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2OperationAck body = ; // C2OperationAck | 
        try {
            apiInstance.acknowledge(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#acknowledge");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ProtocolApi;

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2OperationAck body = ; // C2OperationAck | 
        try {
            apiInstance.acknowledge(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#acknowledge");
            e.printStackTrace();
        }
    }
}

C2OperationAck *body = ; // 

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

// An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
[apiInstance acknowledgeWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolApi()
var body = ; // {{C2OperationAck}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.acknowledge(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ProtocolApi();
            var body = new C2OperationAck(); // C2OperationAck | 

            try
            {
                // An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
                apiInstance.acknowledge(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolApi.acknowledge: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ProtocolApi();
$body = ; // C2OperationAck | 

try {
    $api_instance->acknowledge($body);
} catch (Exception $e) {
    echo 'Exception when calling C2ProtocolApi->acknowledge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::C2ProtocolApi;

my $api_instance = WWW::SwaggerClient::C2ProtocolApi->new();
my $body = WWW::SwaggerClient::Object::C2OperationAck->new(); # C2OperationAck | 

eval { 
    $api_instance->acknowledge(body => $body);
};
if ($@) {
    warn "Exception when calling C2ProtocolApi->acknowledge: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.C2ProtocolApi()
body =  # C2OperationAck | 

try: 
    # An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
    api_instance.acknowledge(body)
except ApiException as e:
    print("Exception when calling C2ProtocolApi->acknowledge: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolApi;

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

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2Heartbeat body = ; // C2Heartbeat | 
        try {
            C2HeartbeatResponse result = apiInstance.heartbeat(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#heartbeat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ProtocolApi;

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2Heartbeat body = ; // C2Heartbeat | 
        try {
            C2HeartbeatResponse result = apiInstance.heartbeat(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#heartbeat");
            e.printStackTrace();
        }
    }
}

C2Heartbeat *body = ; // 

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

// An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
[apiInstance heartbeatWith:body
              completionHandler: ^(C2HeartbeatResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolApi()
var body = ; // {{C2Heartbeat}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ProtocolApi();
            var body = new C2Heartbeat(); // C2Heartbeat | 

            try
            {
                // An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
                C2HeartbeatResponse result = apiInstance.heartbeat(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolApi.heartbeat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ProtocolApi();
$body = ; // C2Heartbeat | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::C2ProtocolApi;

my $api_instance = WWW::SwaggerClient::C2ProtocolApi->new();
my $body = WWW::SwaggerClient::Object::C2Heartbeat->new(); # C2Heartbeat | 

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

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

# create an instance of the API class
api_instance = swagger_client.C2ProtocolApi()
body =  # C2Heartbeat | 

try: 
    # An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
    api_response = api_instance.heartbeat(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolApi->heartbeat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        try {
            Fields result = apiInstance.getAvailableEventFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getAvailableEventFields");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        try {
            Fields result = apiInstance.getAvailableEventFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getAvailableEventFields");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the available field names for searching or sorting events.
[apiInstance getAvailableEventFieldsWithCompletionHandler: 
              ^(Fields output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EventsApi();

            try
            {
                // Retrieves the available field names for searching or sorting events.
                Fields result = apiInstance.getAvailableEventFields();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getAvailableEventFields: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEventsApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EventsApi;

my $api_instance = WWW::SwaggerClient::EventsApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.EventsApi()

try: 
    # Retrieves the available field names for searching or sorting events.
    api_response = api_instance.get_available_event_fields()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getAvailableEventFields: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        String id = id_example; // String | The id of the event to retrieve
        try {
            Event result = apiInstance.getEvent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        String id = id_example; // String | The id of the event to retrieve
        try {
            Event result = apiInstance.getEvent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvent");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of the event to retrieve

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

// Get a specific event
[apiInstance getEventWith:id
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.EventsApi()
var id = id_example; // {{String}} The id of the event to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EventsApi();
            var id = id_example;  // String | The id of the event to retrieve

            try
            {
                // Get a specific event
                Event result = apiInstance.getEvent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEventsApi();
$id = id_example; // String | The id of the event to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EventsApi;

my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $id = id_example; # String | The id of the event to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.EventsApi()
id = id_example # String | The id of the event to retrieve

try: 
    # Get a specific event
    api_response = api_instance.get_event(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvent: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        array[String] sort = ; // array[String] | 
        array[String] filter = ; // array[String] | 
        try {
            ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        array[String] sort = ; // array[String] | 
        array[String] filter = ; // array[String] | 
        try {
            ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}

Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)
array[String] *sort = ; //  (optional)
array[String] *filter = ; //  (optional)

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

// Get events
[apiInstance getEventsWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.EventsApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56, // {{Integer}} 
  'sort': , // {{array[String]}} 
  'filter':  // {{array[String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEvents(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EventsApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 
            var sort = new array[String](); // array[String] |  (optional) 
            var filter = new array[String](); // array[String] |  (optional) 

            try
            {
                // Get events
                ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEventsApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 
$sort = ; // array[String] | 
$filter = ; // array[String] | 

try {
    $result = $api_instance->getEvents($pageNum, $rows, $sort, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventsApi->getEvents: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EventsApi;

my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 
my $sort = []; # array[String] | 
my $filter = []; # array[String] | 

eval { 
    my $result = $api_instance->getEvents(pageNum => $pageNum, rows => $rows, sort => $sort, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->getEvents: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EventsApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)
sort =  # array[String] |  (optional)
filter =  # array[String] |  (optional)

try: 
    # Get events
    api_response = api_instance.get_events(pageNum=pageNum, rows=rows, sort=sort, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvents: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDConnection result = apiInstance.createConnection(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDConnection result = apiInstance.createConnection(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createConnection");
            e.printStackTrace();
        }
    }
}

FDConnection *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Creates a connection in the given process group
[apiInstance createConnectionWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDConnection}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDConnection(); // FDConnection | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a connection in the given process group
                FDConnection result = apiInstance.createConnection(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDConnection | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createConnection($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createConnection: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDConnection->new(); # FDConnection | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createConnection(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createConnection: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDConnection | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a connection in the given process group
    api_response = api_instance.create_connection(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createConnection: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createControllerService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createControllerService");
            e.printStackTrace();
        }
    }
}

FDControllerService *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Creates a controller service in the given process group
[apiInstance createControllerServiceWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDControllerService}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDControllerService(); // FDControllerService | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a controller service in the given process group
                FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createControllerService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDControllerService | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createControllerService($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createControllerService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDControllerService->new(); # FDControllerService | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createControllerService(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createControllerService: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDControllerService | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a controller service in the given process group
    api_response = api_instance.create_controller_service(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createControllerService: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createFunnel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createFunnel");
            e.printStackTrace();
        }
    }
}

FDFunnel *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Creates a funnel in the given process group
[apiInstance createFunnelWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDFunnel}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDFunnel(); // FDFunnel | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a funnel in the given process group
                FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createFunnel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDFunnel | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createFunnel($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createFunnel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDFunnel->new(); # FDFunnel | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createFunnel(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createFunnel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDFunnel | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a funnel in the given process group
    api_response = api_instance.create_funnel(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createFunnel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createProcessor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createProcessor");
            e.printStackTrace();
        }
    }
}

FDProcessor *body = ; // The processor configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Creates a processor in the given process group
[apiInstance createProcessorWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDProcessor}} The processor configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDProcessor(); // FDProcessor | The processor configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a processor in the given process group
                FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createProcessor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDProcessor | The processor configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createProcessor($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createProcessor: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDProcessor->new(); # FDProcessor | The processor configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createProcessor(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createProcessor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDProcessor | The processor configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a processor in the given process group
    api_response = api_instance.create_processor(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createProcessor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

FDRemoteProcessGroup *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Creates a remote process group in the given process group
[apiInstance createRemoteProcessGroupWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDRemoteProcessGroup}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDRemoteProcessGroup(); // FDRemoteProcessGroup | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a remote process group in the given process group
                FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDRemoteProcessGroup | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createRemoteProcessGroup($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createRemoteProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDRemoteProcessGroup->new(); # FDRemoteProcessGroup | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createRemoteProcessGroup(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createRemoteProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDRemoteProcessGroup | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a remote process group in the given process group
    api_response = api_instance.create_remote_process_group(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createRemoteProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteConnection");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

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

// Deletes the connection with the given id in the given flow
[apiInstance deleteConnectionWith:flowId
    connectionId:connectionId
    version:version
    clientId:clientId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var connectionId = connectionId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteConnection(flowId, connectionId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the connection with the given id in the given flow
                FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$connectionId = connectionId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteConnection($flowId, $connectionId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteConnection: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteConnection(flowId => $flowId, connectionId => $connectionId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteConnection: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the connection with the given id in the given flow
    api_response = api_instance.delete_connection(flowId, connectionId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteConnection: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteControllerService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteControllerService");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

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

// Deletes the controller service with the given id in the given flow
[apiInstance deleteControllerServiceWith:flowId
    controllerServiceId:controllerServiceId
    version:version
    clientId:clientId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteControllerService(flowId, controllerServiceId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the controller service with the given id in the given flow
                FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteControllerService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteControllerService($flowId, $controllerServiceId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteControllerService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteControllerService(flowId => $flowId, controllerServiceId => $controllerServiceId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteControllerService: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the controller service with the given id in the given flow
    api_response = api_instance.delete_controller_service(flowId, controllerServiceId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteControllerService: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.deleteFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.deleteFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Deletes the flow with the given id
[apiInstance deleteFlowWith:flowId
              completionHandler: ^(FDFlowMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Deletes the flow with the given id
                FDFlowMetadata result = apiInstance.deleteFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteFlow: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Deletes the flow with the given id
    api_response = api_instance.delete_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteFlow: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFunnel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFunnel");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

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

// Deletes the funnel with the given id in the given flow
[apiInstance deleteFunnelWith:flowId
    funnelId:funnelId
    version:version
    clientId:clientId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var funnelId = funnelId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteFunnel(flowId, funnelId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var funnelId = funnelId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the funnel with the given id in the given flow
                FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteFunnel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$funnelId = funnelId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteFunnel($flowId, $funnelId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteFunnel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $funnelId = funnelId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteFunnel(flowId => $flowId, funnelId => $funnelId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteFunnel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
funnelId = funnelId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the funnel with the given id in the given flow
    api_response = api_instance.delete_funnel(flowId, funnelId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteFunnel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteProcessor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteProcessor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *processorId = processorId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

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

// Deletes the processor with the given id in the given flow
[apiInstance deleteProcessorWith:flowId
    processorId:processorId
    version:version
    clientId:clientId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var processorId = processorId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProcessor(flowId, processorId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the processor with the given id in the given flow
                FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteProcessor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$processorId = processorId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteProcessor($flowId, $processorId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteProcessor: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $processorId = processorId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteProcessor(flowId => $flowId, processorId => $processorId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteProcessor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
processorId = processorId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the processor with the given id in the given flow
    api_response = api_instance.delete_processor(flowId, processorId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteProcessor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

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

// Deletes the remote process group with the given id in the given flow
[apiInstance deleteRemoteProcessGroupWith:flowId
    remoteProcessGroupId:remoteProcessGroupId
    version:version
    clientId:clientId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var remoteProcessGroupId = remoteProcessGroupId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var remoteProcessGroupId = remoteProcessGroupId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$remoteProcessGroupId = remoteProcessGroupId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteRemoteProcessGroup($flowId, $remoteProcessGroupId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $remoteProcessGroupId = remoteProcessGroupId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteRemoteProcessGroup(flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
remoteProcessGroupId = remoteProcessGroupId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the remote process group with the given id in the given flow
    api_response = api_instance.delete_remote_process_group(flowId, remoteProcessGroupId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            'String' result = apiInstance.getClientId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            'String' result = apiInstance.getClientId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientId");
            e.printStackTrace();
        }
    }
}

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

// Gets a client id to use with the designer endpoints
[apiInstance getClientIdWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets a client id to use with the designer endpoints
                'String' result = apiInstance.getClientId();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getClientId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets a client id to use with the designer endpoints
    api_response = api_instance.get_client_id()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getClientId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.getConnection(flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.getConnection(flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getConnection");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 

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

// Retrieves the connection with the given id in the given flow
[apiInstance getConnectionWith:flowId
    connectionId:connectionId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var connectionId = connectionId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 

            try
            {
                // Retrieves the connection with the given id in the given flow
                FDConnection result = apiInstance.getConnection(flowId, connectionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$connectionId = connectionId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 

eval { 
    my $result = $api_instance->getConnection(flowId => $flowId, connectionId => $connectionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getConnection: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 

try: 
    # Retrieves the connection with the given id in the given flow
    api_response = api_instance.get_connection(flowId, connectionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getConnection: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerService");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 

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

// Retrieves the controller service with the given id in the given flow
[apiInstance getControllerServiceWith:flowId
    controllerServiceId:controllerServiceId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 

            try
            {
                // Retrieves the controller service with the given id in the given flow
                FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 

eval { 
    my $result = $api_instance->getControllerService(flowId => $flowId, controllerServiceId => $controllerServiceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerService: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 

try: 
    # Retrieves the controller service with the given id in the given flow
    api_response = api_instance.get_controller_service(flowId, controllerServiceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerService: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServicePropertyDescriptor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServicePropertyDescriptor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 
String *propertyName = propertyName_example; // 

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

// Retrieves the property descriptor with the given name for the given service in the given flow
[apiInstance getControllerServicePropertyDescriptorWith:flowId
    controllerServiceId:controllerServiceId
    propertyName:propertyName
              completionHandler: ^(FDPropertyDescriptor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 
var propertyName = propertyName_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 
            var propertyName = propertyName_example;  // String | 

            try
            {
                // Retrieves the property descriptor with the given name for the given service in the given flow
                FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServicePropertyDescriptor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 
$propertyName = propertyName_example; // String | 

try {
    $result = $api_instance->getControllerServicePropertyDescriptor($flowId, $controllerServiceId, $propertyName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 
my $propertyName = propertyName_example; # String | 

eval { 
    my $result = $api_instance->getControllerServicePropertyDescriptor(flowId => $flowId, controllerServiceId => $controllerServiceId, propertyName => $propertyName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 
propertyName = propertyName_example # String | 

try: 
    # Retrieves the property descriptor with the given name for the given service in the given flow
    api_response = api_instance.get_controller_service_property_descriptor(flowId, controllerServiceId, propertyName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServiceTypes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServiceTypes");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the available controller service types for the given flow
[apiInstance getControllerServiceTypesWith:flowId
              completionHandler: ^(FDComponentTypes output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the available controller service types for the given flow
                FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServiceTypes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the available controller service types for the given flow
    api_response = api_instance.get_controller_service_types(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServiceTypes: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            ListContainer result = apiInstance.getControllerServices(flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServices");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            ListContainer result = apiInstance.getControllerServices(flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServices");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Retrieves the controller service with the given id in the given flow
[apiInstance getControllerServicesWith:flowId
    pgId:pgId
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Retrieves the controller service with the given id in the given flow
                ListContainer result = apiInstance.getControllerServices(flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServices: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->getControllerServices(flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerServices: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Retrieves the controller service with the given id in the given flow
    api_response = api_instance.get_controller_services(flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServices: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ELSpecification result = apiInstance.getELSpecification(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getELSpecification");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ELSpecification result = apiInstance.getELSpecification(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getELSpecification");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the expression language specification for the agent class of the given flow
[apiInstance getELSpecificationWith:flowId
              completionHandler: ^(ELSpecification output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the expression language specification for the agent class of the given flow
                ELSpecification result = apiInstance.getELSpecification(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getELSpecification: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the expression language specification for the agent class of the given flow
    api_response = api_instance.get_el_specification(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getELSpecification: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlow result = apiInstance.getFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlow result = apiInstance.getFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the flow with the given id
[apiInstance getFlowWith:flowId
              completionHandler: ^(FDFlow output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow with the given id
                FDFlow result = apiInstance.getFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlow: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow with the given id
    api_response = api_instance.get_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlow: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ListContainer result = apiInstance.getFlowEvents(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ListContainer result = apiInstance.getFlowEvents(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowEvents");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the flow events for the flow with the given id
[apiInstance getFlowEventsWith:flowId
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow events for the flow with the given id
                ListContainer result = apiInstance.getFlowEvents(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow events for the flow with the given id
    api_response = api_instance.get_flow_events(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowEvents: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the flow metadata for the flow with the given id
[apiInstance getFlowMetadataWith:flowId
              completionHandler: ^(FDFlowMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow metadata for the flow with the given id
                FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowMetadata: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow metadata for the flow with the given id
    api_response = api_instance.get_flow_metadata(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowMetadata: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowSummaries");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowSummaries");
            e.printStackTrace();
        }
    }
}

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

// Gets the summaries of the available flows known to the flow designer
[apiInstance getFlowSummariesWithCompletionHandler: 
              ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets the summaries of the available flows known to the flow designer
                ListContainer result = apiInstance.getFlowSummaries();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowSummaries: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets the summaries of the available flows known to the flow designer
    api_response = api_instance.get_flow_summaries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowSummaries: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the version info for the flow with the given id
[apiInstance getFlowVersionInfoWith:flowId
              completionHandler: ^(FDVersionInfoResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the version info for the flow with the given id
                FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowVersionInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the version info for the flow with the given id
    api_response = api_instance.get_flow_version_info(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowVersionInfo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlows();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlows");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlows();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlows");
            e.printStackTrace();
        }
    }
}

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

// Gets the available flows known to the flow designer
[apiInstance getFlowsWithCompletionHandler: 
              ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets the available flows known to the flow designer
                ListContainer result = apiInstance.getFlows();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlows: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets the available flows known to the flow designer
    api_response = api_instance.get_flows()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlows: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFunnel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFunnel");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 

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

// Retrieves the funnel with the given id in the given flow
[apiInstance getFunnelWith:flowId
    funnelId:funnelId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var funnelId = funnelId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var funnelId = funnelId_example;  // String | 

            try
            {
                // Retrieves the funnel with the given id in the given flow
                FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFunnel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$funnelId = funnelId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $funnelId = funnelId_example; # String | 

eval { 
    my $result = $api_instance->getFunnel(flowId => $flowId, funnelId => $funnelId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getFunnel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
funnelId = funnelId_example # String | 

try: 
    # Retrieves the funnel with the given id in the given flow
    api_response = api_instance.get_funnel(flowId, funnelId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFunnel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        Boolean includeChildren = true; // Boolean | 
        try {
            FDProcessGroup result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        Boolean includeChildren = true; // Boolean | 
        try {
            FDProcessGroup result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessGroup");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *pgId = pgId_example; // 
Boolean *includeChildren = true; //  (optional)

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

// Retrieves the process group with the given id. The alias of 'root' may be used to retrieve the root process group for the given flow.
[apiInstance getProcessGroupWith:flowId
    pgId:pgId
    includeChildren:includeChildren
              completionHandler: ^(FDProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 
var opts = { 
  'includeChildren': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcessGroup(flowId, pgId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 
            var includeChildren = true;  // Boolean |  (optional) 

            try
            {
                // Retrieves the process group with the given id. The alias of 'root' may be used to retrieve the root process group for the given flow.
                FDProcessGroup result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 
$includeChildren = true; // Boolean | 

try {
    $result = $api_instance->getProcessGroup($flowId, $pgId, $includeChildren);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 
my $includeChildren = true; # Boolean | 

eval { 
    my $result = $api_instance->getProcessGroup(flowId => $flowId, pgId => $pgId, includeChildren => $includeChildren);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
pgId = pgId_example # String | 
includeChildren = true # Boolean |  (optional)

try: 
    # Retrieves the process group with the given id. The alias of 'root' may be used to retrieve the root process group for the given flow.
    api_response = api_instance.get_process_group(flowId, pgId, includeChildren=includeChildren)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.getProcessor(flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.getProcessor(flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *processorId = processorId_example; // 

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

// Retrieves the processor with the given id in the given flow
[apiInstance getProcessorWith:flowId
    processorId:processorId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var processorId = processorId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 

            try
            {
                // Retrieves the processor with the given id in the given flow
                FDProcessor result = apiInstance.getProcessor(flowId, processorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$processorId = processorId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $processorId = processorId_example; # String | 

eval { 
    my $result = $api_instance->getProcessor(flowId => $flowId, processorId => $processorId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
processorId = processorId_example # String | 

try: 
    # Retrieves the processor with the given id in the given flow
    api_response = api_instance.get_processor(flowId, processorId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorPropertyDescriptor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorPropertyDescriptor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *processorId = processorId_example; // 
String *propertyName = propertyName_example; // 

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

// Retrieves the property descriptor with the given name from the given processor in the given flow
[apiInstance getProcessorPropertyDescriptorWith:flowId
    processorId:processorId
    propertyName:propertyName
              completionHandler: ^(FDPropertyDescriptor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var processorId = processorId_example; // {{String}} 
var propertyName = propertyName_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 
            var propertyName = propertyName_example;  // String | 

            try
            {
                // Retrieves the property descriptor with the given name from the given processor in the given flow
                FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessorPropertyDescriptor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$processorId = processorId_example; // String | 
$propertyName = propertyName_example; // String | 

try {
    $result = $api_instance->getProcessorPropertyDescriptor($flowId, $processorId, $propertyName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $processorId = processorId_example; # String | 
my $propertyName = propertyName_example; # String | 

eval { 
    my $result = $api_instance->getProcessorPropertyDescriptor(flowId => $flowId, processorId => $processorId, propertyName => $propertyName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
processorId = processorId_example # String | 
propertyName = propertyName_example # String | 

try: 
    # Retrieves the property descriptor with the given name from the given processor in the given flow
    api_response = api_instance.get_processor_property_descriptor(flowId, processorId, propertyName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getProcessorTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorTypes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getProcessorTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorTypes");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the available processor types for the given flow
[apiInstance getProcessorTypesWith:flowId
              completionHandler: ^(FDComponentTypes output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the available processor types for the given flow
                FDComponentTypes result = apiInstance.getProcessorTypes(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessorTypes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the available processor types for the given flow
    api_response = api_instance.get_processor_types(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessorTypes: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 

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

// Retrieves the remote process group with the given id in the given flow
[apiInstance getRemoteProcessGroupWith:flowId
    remoteProcessGroupId:remoteProcessGroupId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var remoteProcessGroupId = remoteProcessGroupId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var remoteProcessGroupId = remoteProcessGroupId_example;  // String | 

            try
            {
                // Retrieves the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$remoteProcessGroupId = remoteProcessGroupId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $remoteProcessGroupId = remoteProcessGroupId_example; # String | 

eval { 
    my $result = $api_instance->getRemoteProcessGroup(flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getRemoteProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
remoteProcessGroupId = remoteProcessGroupId_example # String | 

try: 
    # Retrieves the remote process group with the given id in the given flow
    api_response = api_instance.get_remote_process_group(flowId, remoteProcessGroupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getRemoteProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        FDFlowPublishMetadata body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#publishFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        FDFlowPublishMetadata body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#publishFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
FDFlowPublishMetadata *body = ; // The metadata for publishing the flow, such as comments (optional)

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

// Publishes the current state of the flow to NiFi Registry
[apiInstance publishFlowWith:flowId
    body:body
              completionHandler: ^(FDVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var opts = { 
  'body':  // {{FDFlowPublishMetadata}} The metadata for publishing the flow, such as comments
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.publishFlow(flowId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var body = new FDFlowPublishMetadata(); // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments (optional) 

            try
            {
                // Publishes the current state of the flow to NiFi Registry
                FDVersionInfo result = apiInstance.publishFlow(flowId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.publishFlow: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $body = WWW::SwaggerClient::Object::FDFlowPublishMetadata->new(); # FDFlowPublishMetadata | The metadata for publishing the flow, such as comments

eval { 
    my $result = $api_instance->publishFlow(flowId => $flowId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->publishFlow: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
body =  # FDFlowPublishMetadata | The metadata for publishing the flow, such as comments (optional)

try: 
    # Publishes the current state of the flow to NiFi Registry
    api_response = api_instance.publish_flow(flowId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->publishFlow: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfo result = apiInstance.revertFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#revertFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfo result = apiInstance.revertFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#revertFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
[apiInstance revertFlowWith:flowId
              completionHandler: ^(FDVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
                FDVersionInfo result = apiInstance.revertFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.revertFlow: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
    api_response = api_instance.revert_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->revertFlow: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The connection configuration details.
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The connection configuration details.
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateConnection");
            e.printStackTrace();
        }
    }
}

FDConnection *body = ; // The connection configuration details.
String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 

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

// Updates the connection with the given id in the given flow
[apiInstance updateConnectionWith:body
    flowId:flowId
    connectionId:connectionId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDConnection}} The connection configuration details.
var flowId = flowId_example; // {{String}} 
var connectionId = connectionId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDConnection(); // FDConnection | The connection configuration details.
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 

            try
            {
                // Updates the connection with the given id in the given flow
                FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDConnection | The connection configuration details.
$flowId = flowId_example; // String | 
$connectionId = connectionId_example; // String | 

try {
    $result = $api_instance->updateConnection($body, $flowId, $connectionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateConnection: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDConnection->new(); # FDConnection | The connection configuration details.
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 

eval { 
    my $result = $api_instance->updateConnection(body => $body, flowId => $flowId, connectionId => $connectionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateConnection: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDConnection | The connection configuration details.
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 

try: 
    # Updates the connection with the given id in the given flow
    api_response = api_instance.update_connection(body, flowId, connectionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateConnection: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The controller service configuration details.
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateControllerService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The controller service configuration details.
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateControllerService");
            e.printStackTrace();
        }
    }
}

FDControllerService *body = ; // The controller service configuration details.
String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 

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

// Updates the controller service with the given id in the given flow
[apiInstance updateControllerServiceWith:body
    flowId:flowId
    controllerServiceId:controllerServiceId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDControllerService}} The controller service configuration details.
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDControllerService(); // FDControllerService | The controller service configuration details.
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 

            try
            {
                // Updates the controller service with the given id in the given flow
                FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateControllerService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDControllerService | The controller service configuration details.
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 

try {
    $result = $api_instance->updateControllerService($body, $flowId, $controllerServiceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateControllerService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDControllerService->new(); # FDControllerService | The controller service configuration details.
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 

eval { 
    my $result = $api_instance->updateControllerService(body => $body, flowId => $flowId, controllerServiceId => $controllerServiceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateControllerService: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDControllerService | The controller service configuration details.
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 

try: 
    # Updates the controller service with the given id in the given flow
    api_response = api_instance.update_controller_service(body, flowId, controllerServiceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateControllerService: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The funnel configuration details.
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateFunnel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The funnel configuration details.
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateFunnel");
            e.printStackTrace();
        }
    }
}

FDFunnel *body = ; // The funnel configuration details.
String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 

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

// Updates the funnel with the given id in the given flow
[apiInstance updateFunnelWith:body
    flowId:flowId
    funnelId:funnelId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDFunnel}} The funnel configuration details.
var flowId = flowId_example; // {{String}} 
var funnelId = funnelId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDFunnel(); // FDFunnel | The funnel configuration details.
            var flowId = flowId_example;  // String | 
            var funnelId = funnelId_example;  // String | 

            try
            {
                // Updates the funnel with the given id in the given flow
                FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateFunnel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDFunnel | The funnel configuration details.
$flowId = flowId_example; // String | 
$funnelId = funnelId_example; // String | 

try {
    $result = $api_instance->updateFunnel($body, $flowId, $funnelId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateFunnel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDFunnel->new(); # FDFunnel | The funnel configuration details.
my $flowId = flowId_example; # String | 
my $funnelId = funnelId_example; # String | 

eval { 
    my $result = $api_instance->updateFunnel(body => $body, flowId => $flowId, funnelId => $funnelId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateFunnel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDFunnel | The funnel configuration details.
flowId = flowId_example # String | 
funnelId = funnelId_example # String | 

try: 
    # Updates the funnel with the given id in the given flow
    api_response = api_instance.update_funnel(body, flowId, funnelId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateFunnel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessGroup body = ; // FDProcessGroup | 
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessGroup body = ; // FDProcessGroup | 
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessGroup");
            e.printStackTrace();
        }
    }
}

FDProcessGroup *body = ; // 
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

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

// Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
[apiInstance updateProcessGroupWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDProcessGroup}} 
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDProcessGroup(); // FDProcessGroup | 
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
                FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDProcessGroup | 
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->updateProcessGroup($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDProcessGroup->new(); # FDProcessGroup | 
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->updateProcessGroup(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDProcessGroup | 
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
    api_response = api_instance.update_process_group(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessor");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessor");
            e.printStackTrace();
        }
    }
}

FDProcessor *body = ; // The processor configuration details.
String *flowId = flowId_example; // 
String *processorId = processorId_example; // 

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

// Updates the processor with the given id in the given flow
[apiInstance updateProcessorWith:body
    flowId:flowId
    processorId:processorId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDProcessor}} The processor configuration details.
var flowId = flowId_example; // {{String}} 
var processorId = processorId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDProcessor(); // FDProcessor | The processor configuration details.
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 

            try
            {
                // Updates the processor with the given id in the given flow
                FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateProcessor: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDProcessor | The processor configuration details.
$flowId = flowId_example; // String | 
$processorId = processorId_example; // String | 

try {
    $result = $api_instance->updateProcessor($body, $flowId, $processorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateProcessor: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDProcessor->new(); # FDProcessor | The processor configuration details.
my $flowId = flowId_example; # String | 
my $processorId = processorId_example; # String | 

eval { 
    my $result = $api_instance->updateProcessor(body => $body, flowId => $flowId, processorId => $processorId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateProcessor: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDProcessor | The processor configuration details.
flowId = flowId_example # String | 
processorId = processorId_example # String | 

try: 
    # Updates the processor with the given id in the given flow
    api_response = api_instance.update_processor(body, flowId, processorId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateProcessor: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The remoteProcessGroup configuration details.
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The remoteProcessGroup configuration details.
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

FDRemoteProcessGroup *body = ; // The remoteProcessGroup configuration details.
String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 

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

// Updates the remote process group with the given id in the given flow
[apiInstance updateRemoteProcessGroupWith:body
    flowId:flowId
    remoteProcessGroupId:remoteProcessGroupId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDRemoteProcessGroup}} The remoteProcessGroup configuration details.
var flowId = flowId_example; // {{String}} 
var remoteProcessGroupId = remoteProcessGroupId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDRemoteProcessGroup(); // FDRemoteProcessGroup | The remoteProcessGroup configuration details.
            var flowId = flowId_example;  // String | 
            var remoteProcessGroupId = remoteProcessGroupId_example;  // String | 

            try
            {
                // Updates the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDRemoteProcessGroup | The remoteProcessGroup configuration details.
$flowId = flowId_example; // String | 
$remoteProcessGroupId = remoteProcessGroupId_example; // String | 

try {
    $result = $api_instance->updateRemoteProcessGroup($body, $flowId, $remoteProcessGroupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateRemoteProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDRemoteProcessGroup->new(); # FDRemoteProcessGroup | The remoteProcessGroup configuration details.
my $flowId = flowId_example; # String | 
my $remoteProcessGroupId = remoteProcessGroupId_example; # String | 

eval { 
    my $result = $api_instance->updateRemoteProcessGroup(body => $body, flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateRemoteProcessGroup: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDRemoteProcessGroup | The remoteProcessGroup configuration details.
flowId = flowId_example # String | 
remoteProcessGroupId = remoteProcessGroupId_example # String | 

try: 
    # Updates the remote process group with the given id in the given flow
    api_response = api_instance.update_remote_process_group(body, flowId, remoteProcessGroupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateRemoteProcessGroup: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContext body = ; // FDParameterContext | The new parameter context
        try {
            FDParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContext body = ; // FDParameterContext | The new parameter context
        try {
            FDParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}

FDParameterContext *body = ; // The new parameter context

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

// Create a parameter context
[apiInstance createParameterContextWith:body
              completionHandler: ^(FDParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var body = ; // {{FDParameterContext}} The new parameter context

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var body = new FDParameterContext(); // FDParameterContext | The new parameter context

            try
            {
                // Create a parameter context
                FDParameterContext result = apiInstance.createParameterContext(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.createParameterContext: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$body = ; // FDParameterContext | The new parameter context

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $body = WWW::SwaggerClient::Object::FDParameterContext->new(); # FDParameterContext | The new parameter context

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
body =  # FDParameterContext | The new parameter context

try: 
    # Create a parameter context
    api_response = api_instance.create_parameter_context(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->createParameterContext: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of the parameter context

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

// Delete a parameter context
[apiInstance deleteParameterContextWith:id
              completionHandler: ^(FDParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var id = id_example; // {{String}} The id of the parameter context

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Delete a parameter context
                FDParameterContext result = apiInstance.deleteParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.deleteParameterContext: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$id = id_example; // String | The id of the parameter context

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $id = id_example; # String | The id of the parameter context

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Delete a parameter context
    api_response = api_instance.delete_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->deleteParameterContext: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String requestId = requestId_example; // String | The update request id
        try {
            FDParameterContextUpdateRequest result = apiInstance.deleteUpdateRequest(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteUpdateRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String requestId = requestId_example; // String | The update request id
        try {
            FDParameterContextUpdateRequest result = apiInstance.deleteUpdateRequest(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteUpdateRequest");
            e.printStackTrace();
        }
    }
}

String *requestId = requestId_example; // The update request id

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

// Delete a completed request or cancel an in-progress request
[apiInstance deleteUpdateRequestWith:requestId
              completionHandler: ^(FDParameterContextUpdateRequest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var requestId = requestId_example; // {{String}} The update request id

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var requestId = requestId_example;  // String | The update request id

            try
            {
                // Delete a completed request or cancel an in-progress request
                FDParameterContextUpdateRequest result = apiInstance.deleteUpdateRequest(requestId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.deleteUpdateRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$requestId = requestId_example; // String | The update request id

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $requestId = requestId_example; # String | The update request id

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
requestId = requestId_example # String | The update request id

try: 
    # Delete a completed request or cancel an in-progress request
    api_response = api_instance.delete_update_request(requestId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->deleteUpdateRequest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of the parameter context

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

// Gets a parameter context
[apiInstance getParameterContextWith:id
              completionHandler: ^(FDParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var id = id_example; // {{String}} The id of the parameter context

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Gets a parameter context
                FDParameterContext result = apiInstance.getParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.getParameterContext: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$id = id_example; // String | The id of the parameter context

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $id = id_example; # String | The id of the parameter context

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Gets a parameter context
    api_response = api_instance.get_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->getParameterContext: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ListContainer result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ListContainer result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}

Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)

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

// Gets all available parameter contexts
[apiInstance getParameterContextsWith:pageNum
    rows:rows
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParameterContexts(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 

            try
            {
                // Gets all available parameter contexts
                ListContainer result = apiInstance.getParameterContexts(pageNum, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.getParameterContexts: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 

eval { 
    my $result = $api_instance->getParameterContexts(pageNum => $pageNum, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->getParameterContexts: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)

try: 
    # Gets all available parameter contexts
    api_response = api_instance.get_parameter_contexts(pageNum=pageNum, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->getParameterContexts: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String requestId = requestId_example; // String | The update request id
        try {
            FDParameterContextUpdateRequest result = apiInstance.getUpdateRequest(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getUpdateRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String requestId = requestId_example; // String | The update request id
        try {
            FDParameterContextUpdateRequest result = apiInstance.getUpdateRequest(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getUpdateRequest");
            e.printStackTrace();
        }
    }
}

String *requestId = requestId_example; // The update request id

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

// Retrieve the status of a update request
[apiInstance getUpdateRequestWith:requestId
              completionHandler: ^(FDParameterContextUpdateRequest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var requestId = requestId_example; // {{String}} The update request id

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var requestId = requestId_example;  // String | The update request id

            try
            {
                // Retrieve the status of a update request
                FDParameterContextUpdateRequest result = apiInstance.getUpdateRequest(requestId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.getUpdateRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$requestId = requestId_example; // String | The update request id

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $requestId = requestId_example; # String | The update request id

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
requestId = requestId_example # String | The update request id

try: 
    # Retrieve the status of a update request
    api_response = api_instance.get_update_request(requestId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->getUpdateRequest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

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

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContextUpdateRequest body = ; // FDParameterContextUpdateRequest | The update request
        try {
            FDParameterContextUpdateRequest result = apiInstance.submitUpdateRequest(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#submitUpdateRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContextUpdateRequest body = ; // FDParameterContextUpdateRequest | The update request
        try {
            FDParameterContextUpdateRequest result = apiInstance.submitUpdateRequest(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#submitUpdateRequest");
            e.printStackTrace();
        }
    }
}

FDParameterContextUpdateRequest *body = ; // The update request

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

// Initiate a update request to apply a proposed change to a context
[apiInstance submitUpdateRequestWith:body
              completionHandler: ^(FDParameterContextUpdateRequest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerParametersApi()
var body = ; // {{FDParameterContextUpdateRequest}} The update request

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerParametersApi();
            var body = new FDParameterContextUpdateRequest(); // FDParameterContextUpdateRequest | The update request

            try
            {
                // Initiate a update request to apply a proposed change to a context
                FDParameterContextUpdateRequest result = apiInstance.submitUpdateRequest(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.submitUpdateRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$body = ; // FDParameterContextUpdateRequest | The update request

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $body = WWW::SwaggerClient::Object::FDParameterContextUpdateRequest->new(); # FDParameterContextUpdateRequest | The update request

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

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerParametersApi()
body =  # FDParameterContextUpdateRequest | The update request

try: 
    # Initiate a update request to apply a proposed change to a context
    api_response = api_instance.submit_update_request(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->submitUpdateRequest: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to create
        try {
            apiInstance.createFlowMapping(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#createFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to create
        try {
            apiInstance.createFlowMapping(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#createFlowMapping");
            e.printStackTrace();
        }
    }
}

FlowMapping *body = ; // The flow mapping to create

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

// Creates a flow mapping. [BETA]
[apiInstance createFlowMappingWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowMappingsApi()
var body = ; // {{FlowMapping}} The flow mapping to create

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createFlowMapping(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var body = new FlowMapping(); // FlowMapping | The flow mapping to create

            try
            {
                // Creates a flow mapping. [BETA]
                apiInstance.createFlowMapping(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.createFlowMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$body = ; // FlowMapping | The flow mapping to create

try {
    $api_instance->createFlowMapping($body);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->createFlowMapping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $body = WWW::SwaggerClient::Object::FlowMapping->new(); # FlowMapping | The flow mapping to create

eval { 
    $api_instance->createFlowMapping(body => $body);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->createFlowMapping: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowMappingsApi()
body =  # FlowMapping | The flow mapping to create

try: 
    # Creates a flow mapping. [BETA]
    api_instance.create_flow_mapping(body)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->createFlowMapping: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for
        try {
            FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#deleteFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for
        try {
            FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#deleteFlowMapping");
            e.printStackTrace();
        }
    }
}

String *agentClassName = agentClassName_example; // The name of the class to delete the mapping for

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

// Deletes a flow mapping. [BETA]
[apiInstance deleteFlowMappingWith:agentClassName
              completionHandler: ^(FlowMapping output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowMappingsApi()
var agentClassName = agentClassName_example; // {{String}} The name of the class to delete the mapping for

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var agentClassName = agentClassName_example;  // String | The name of the class to delete the mapping for

            try
            {
                // Deletes a flow mapping. [BETA]
                FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.deleteFlowMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $agentClassName = agentClassName_example; # String | The name of the class to delete the mapping for

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

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

# create an instance of the API class
api_instance = swagger_client.FlowMappingsApi()
agentClassName = agentClassName_example # String | The name of the class to delete the mapping for

try: 
    # Deletes a flow mapping. [BETA]
    api_response = api_instance.delete_flow_mapping(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->deleteFlowMapping: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        try {
            FlowMappings result = apiInstance.getAllFlowMappings();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#getAllFlowMappings");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        try {
            FlowMappings result = apiInstance.getAllFlowMappings();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#getAllFlowMappings");
            e.printStackTrace();
        }
    }
}

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

// Gets all flow mappings. [BETA]
[apiInstance getAllFlowMappingsWithCompletionHandler: 
              ^(FlowMappings output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();

            try
            {
                // Gets all flow mappings. [BETA]
                FlowMappings result = apiInstance.getAllFlowMappings();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.getAllFlowMappings: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowMappingsApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.FlowMappingsApi()

try: 
    # Gets all flow mappings. [BETA]
    api_response = api_instance.get_all_flow_mappings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->getAllFlowMappings: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to retrieve
        try {
            FlowMapping result = apiInstance.getFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#getFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to retrieve
        try {
            FlowMapping result = apiInstance.getFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#getFlowMapping");
            e.printStackTrace();
        }
    }
}

String *agentClassName = agentClassName_example; // The name of the class to retrieve

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

// Gets a flow mapping for a given agent class. [BETA]
[apiInstance getFlowMappingWith:agentClassName
              completionHandler: ^(FlowMapping output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowMappingsApi()
var agentClassName = agentClassName_example; // {{String}} The name of the class to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var agentClassName = agentClassName_example;  // String | The name of the class to retrieve

            try
            {
                // Gets a flow mapping for a given agent class. [BETA]
                FlowMapping result = apiInstance.getFlowMapping(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.getFlowMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$agentClassName = agentClassName_example; // String | The name of the class to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $agentClassName = agentClassName_example; # String | The name of the class to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.FlowMappingsApi()
agentClassName = agentClassName_example # String | The name of the class to retrieve

try: 
    # Gets a flow mapping for a given agent class. [BETA]
    api_response = api_instance.get_flow_mapping(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->getFlowMapping: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to update
        String agentClassName = agentClassName_example; // String | The name of the class to update the mapping for
        try {
            FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#updateFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to update
        String agentClassName = agentClassName_example; // String | The name of the class to update the mapping for
        try {
            FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#updateFlowMapping");
            e.printStackTrace();
        }
    }
}

FlowMapping *body = ; // The flow mapping to update
String *agentClassName = agentClassName_example; // The name of the class to update the mapping for

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

// Updates a flow mapping. [BETA]
[apiInstance updateFlowMappingWith:body
    agentClassName:agentClassName
              completionHandler: ^(FlowMapping output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowMappingsApi()
var body = ; // {{FlowMapping}} The flow mapping to update
var agentClassName = agentClassName_example; // {{String}} The name of the class to update the mapping for

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var body = new FlowMapping(); // FlowMapping | The flow mapping to update
            var agentClassName = agentClassName_example;  // String | The name of the class to update the mapping for

            try
            {
                // Updates a flow mapping. [BETA]
                FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.updateFlowMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$body = ; // FlowMapping | The flow mapping to update
$agentClassName = agentClassName_example; // String | The name of the class to update the mapping for

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $body = WWW::SwaggerClient::Object::FlowMapping->new(); # FlowMapping | The flow mapping to update
my $agentClassName = agentClassName_example; # String | The name of the class to update the mapping for

eval { 
    my $result = $api_instance->updateFlowMapping(body => $body, agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->updateFlowMapping: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowMappingsApi()
body =  # FlowMapping | The flow mapping to update
agentClassName = agentClassName_example # String | The name of the class to update the mapping for

try: 
    # Updates a flow mapping. [BETA]
    api_response = api_instance.update_flow_mapping(body, agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->updateFlowMapping: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        FlowSnapshot body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot
        try {
            FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowFromFlowSnapshot");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        FlowSnapshot body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot
        try {
            FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowFromFlowSnapshot");
            e.printStackTrace();
        }
    }
}

FlowSnapshot *body = ; // The flow snapshot containing the flow URI and VersionedFlowSnapshot

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

// Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
[apiInstance createFlowFromFlowSnapshotWith:body
              completionHandler: ^(FlowSummary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowsApi()
var body = ; // {{FlowSnapshot}} The flow snapshot containing the flow URI and VersionedFlowSnapshot

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();
            var body = new FlowSnapshot(); // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

            try
            {
                // Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
                FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.createFlowFromFlowSnapshot: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowsApi();
$body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $body = WWW::SwaggerClient::Object::FlowSnapshot->new(); # FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

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

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

# create an instance of the API class
api_instance = swagger_client.FlowsApi()
body =  # FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

try: 
    # Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
    api_response = api_instance.create_flow_from_flow_snapshot(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->createFlowFromFlowSnapshot: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        try {
            FlowSummaries result = apiInstance.getAllFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getAllFlowSummaries");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        try {
            FlowSummaries result = apiInstance.getAllFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getAllFlowSummaries");
            e.printStackTrace();
        }
    }
}

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

// Gets all flow summaries. [BETA]
[apiInstance getAllFlowSummariesWithCompletionHandler: 
              ^(FlowSummaries output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();

            try
            {
                // Gets all flow summaries. [BETA]
                FlowSummaries result = apiInstance.getAllFlowSummaries();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getAllFlowSummaries: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowsApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.FlowsApi()

try: 
    # Gets all flow summaries. [BETA]
    api_response = api_instance.get_all_flow_summaries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getAllFlowSummaries: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            Flow result = apiInstance.getFlow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            Flow result = apiInstance.getFlow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlow");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of a flow to retrieve

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

// Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
[apiInstance getFlowWith:id
              completionHandler: ^(Flow output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowsApi()
var id = id_example; // {{String}} The id of a flow to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The id of a flow to retrieve

            try
            {
                // Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
                Flow result = apiInstance.getFlow(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getFlow: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The id of a flow to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $id = id_example; # String | The id of a flow to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.FlowsApi()
id = id_example # String | The id of a flow to retrieve

try: 
    # Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
    api_response = api_instance.get_flow(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getFlow: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific context to use with the requested flow.  This is overlaid over any class values.
        try {
            'String' result = apiInstance.getFlowContentAsYaml(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowContentAsYaml");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific context to use with the requested flow.  This is overlaid over any class values.
        try {
            'String' result = apiInstance.getFlowContentAsYaml(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowContentAsYaml");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of a flow to retrieve
String *aid = aid_example; // The specific context to use with the requested flow.  This is overlaid over any class values. (optional)

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

// Get a flow by id as a YAML formatted flow definition
[apiInstance getFlowContentAsYamlWith:id
    aid:aid
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowsApi()
var id = id_example; // {{String}} The id of a flow to retrieve
var opts = { 
  'aid': aid_example // {{String}} The specific context to use with the requested flow.  This is overlaid over any class values.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowContentAsYaml(id, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The id of a flow to retrieve
            var aid = aid_example;  // String | The specific context to use with the requested flow.  This is overlaid over any class values. (optional) 

            try
            {
                // Get a flow by id as a YAML formatted flow definition
                'String' result = apiInstance.getFlowContentAsYaml(id, aid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getFlowContentAsYaml: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The id of a flow to retrieve
$aid = aid_example; // String | The specific context to use with the requested flow.  This is overlaid over any class values.

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $id = id_example; # String | The id of a flow to retrieve
my $aid = aid_example; # String | The specific context to use with the requested flow.  This is overlaid over any class values.

eval { 
    my $result = $api_instance->getFlowContentAsYaml(id => $id, aid => $aid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->getFlowContentAsYaml: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FlowsApi()
id = id_example # String | The id of a flow to retrieve
aid = aid_example # String | The specific context to use with the requested flow.  This is overlaid over any class values. (optional)

try: 
    # Get a flow by id as a YAML formatted flow definition
    api_response = api_instance.get_flow_content_as_yaml(id, aid=aid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getFlowContentAsYaml: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HeartbeatsApi;

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

public class HeartbeatsApiExample {

    public static void main(String[] args) {
        
        HeartbeatsApi apiInstance = new HeartbeatsApi();
        String id = id_example; // String | The identifier of the heartbeat to retrieve
        try {
            C2Heartbeat result = apiInstance.getHeartbeat(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HeartbeatsApi#getHeartbeat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HeartbeatsApi;

public class HeartbeatsApiExample {

    public static void main(String[] args) {
        HeartbeatsApi apiInstance = new HeartbeatsApi();
        String id = id_example; // String | The identifier of the heartbeat to retrieve
        try {
            C2Heartbeat result = apiInstance.getHeartbeat(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HeartbeatsApi#getHeartbeat");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the heartbeat to retrieve

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

// Get a specific heartbeat
[apiInstance getHeartbeatWith:id
              completionHandler: ^(C2Heartbeat output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.HeartbeatsApi()
var id = id_example; // {{String}} The identifier of the heartbeat to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new HeartbeatsApi();
            var id = id_example;  // String | The identifier of the heartbeat to retrieve

            try
            {
                // Get a specific heartbeat
                C2Heartbeat result = apiInstance.getHeartbeat(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HeartbeatsApi.getHeartbeat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiHeartbeatsApi();
$id = id_example; // String | The identifier of the heartbeat to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HeartbeatsApi;

my $api_instance = WWW::SwaggerClient::HeartbeatsApi->new();
my $id = id_example; # String | The identifier of the heartbeat to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.HeartbeatsApi()
id = id_example # String | The identifier of the heartbeat to retrieve

try: 
    # Get a specific heartbeat
    api_response = api_instance.get_heartbeat(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HeartbeatsApi->getHeartbeat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

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

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassDetail");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassDetail");
            e.printStackTrace();
        }
    }
}

String *agentClass = agentClass_example; // 

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

// Get agent class monitoring data
[apiInstance getAgentClassDetailWith:agentClass
              completionHandler: ^(AgentClassDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.MonitoringApi()
var agentClass = agentClass_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MonitoringApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Get agent class monitoring data
                AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassDetail: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentClass = agentClass_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentClass = agentClass_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.MonitoringApi()
agentClass = agentClass_example # String | 

try: 
    # Get agent class monitoring data
    api_response = api_instance.get_agent_class_detail(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassDetail: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

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

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ListContainer result = apiInstance.getAgentClassSummaries(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummaries");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ListContainer result = apiInstance.getAgentClassSummaries(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummaries");
            e.printStackTrace();
        }
    }
}

Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)

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

// Get summaries of all agent classes
[apiInstance getAgentClassSummariesWith:pageNum
    rows:rows
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.MonitoringApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassSummaries(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MonitoringApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 

            try
            {
                // Get summaries of all agent classes
                ListContainer result = apiInstance.getAgentClassSummaries(pageNum, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassSummaries: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMonitoringApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 

eval { 
    my $result = $api_instance->getAgentClassSummaries(pageNum => $pageNum, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getAgentClassSummaries: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MonitoringApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)

try: 
    # Get summaries of all agent classes
    api_response = api_instance.get_agent_class_summaries(pageNum=pageNum, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassSummaries: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

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

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummary");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummary");
            e.printStackTrace();
        }
    }
}

String *agentClass = agentClass_example; // 

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

// Get summaries of all agent classes
[apiInstance getAgentClassSummaryWith:agentClass
              completionHandler: ^(AgentClassSummary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.MonitoringApi()
var agentClass = agentClass_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MonitoringApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Get summaries of all agent classes
                AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassSummary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentClass = agentClass_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentClass = agentClass_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.MonitoringApi()
agentClass = agentClass_example # String | 

try: 
    # Get summaries of all agent classes
    api_response = api_instance.get_agent_class_summary(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassSummary: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

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

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentId = agentId_example; // String | 
        try {
            AgentDetail result = apiInstance.getAgentDetail(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentDetail");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentId = agentId_example; // String | 
        try {
            AgentDetail result = apiInstance.getAgentDetail(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentDetail");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // 

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

// Get agent monitoring data
[apiInstance getAgentDetailWith:agentId
              completionHandler: ^(AgentDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.MonitoringApi()
var agentId = agentId_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MonitoringApi();
            var agentId = agentId_example;  // String | 

            try
            {
                // Get agent monitoring data
                AgentDetail result = apiInstance.getAgentDetail(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentDetail: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentId = agentId_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentId = agentId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.MonitoringApi()
agentId = agentId_example # String | 

try: 
    # Get agent monitoring data
    api_response = api_instance.get_agent_detail(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentDetail: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

    public static void main(String[] args) {
        
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | The requested operation
        try {
            Operation result = apiInstance.createOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#createOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

    public static void main(String[] args) {
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | The requested operation
        try {
            Operation result = apiInstance.createOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#createOperation");
            e.printStackTrace();
        }
    }
}

Operation *body = ; // The requested operation

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

// Submit a request for a C2 operation targeting a MiNiFi agent
[apiInstance createOperationWith:body
              completionHandler: ^(Operation output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.OperationsApi()
var body = ; // {{Operation}} The requested operation

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OperationsApi();
            var body = new Operation(); // Operation | The requested operation

            try
            {
                // Submit a request for a C2 operation targeting a MiNiFi agent
                Operation result = apiInstance.createOperation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.createOperation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOperationsApi();
$body = ; // Operation | The requested operation

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

my $api_instance = WWW::SwaggerClient::OperationsApi->new();
my $body = WWW::SwaggerClient::Object::Operation->new(); # Operation | The requested operation

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

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

# create an instance of the API class
api_instance = swagger_client.OperationsApi()
body =  # Operation | The requested operation

try: 
    # Submit a request for a C2 operation targeting a MiNiFi agent
    api_response = api_instance.create_operation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->createOperation: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

    public static void main(String[] args) {
        
        OperationsApi apiInstance = new OperationsApi();
        String id = id_example; // String | The identifier of the operation to retrieve
        try {
            Operation result = apiInstance.getOperation(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#getOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

    public static void main(String[] args) {
        OperationsApi apiInstance = new OperationsApi();
        String id = id_example; // String | The identifier of the operation to retrieve
        try {
            Operation result = apiInstance.getOperation(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#getOperation");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The identifier of the operation to retrieve

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

// Get a specific operation
[apiInstance getOperationWith:id
              completionHandler: ^(Operation output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.OperationsApi()
var id = id_example; // {{String}} The identifier of the operation to retrieve

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OperationsApi();
            var id = id_example;  // String | The identifier of the operation to retrieve

            try
            {
                // Get a specific operation
                Operation result = apiInstance.getOperation(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.getOperation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOperationsApi();
$id = id_example; // String | The identifier of the operation to retrieve

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

my $api_instance = WWW::SwaggerClient::OperationsApi->new();
my $id = id_example; # String | The identifier of the operation to retrieve

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

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

# create an instance of the API class
api_instance = swagger_client.OperationsApi()
id = id_example # String | The identifier of the operation to retrieve

try: 
    # Get a specific operation
    api_response = api_instance.get_operation(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->getOperation: %s\n" % e)