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.
[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.
                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.
    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.AccessApi;

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

public class AccessApiExample {

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

import io.swagger.client.api.AccessApi;

public class AccessApiExample {

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

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

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

// Returns the current client's access to the given agent class.
[apiInstance getAgentClassAccessWith:name
              completionHandler: ^(AgentClassPermissions 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 name = name_example; // {{String}} The name of the agent class to lookup

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

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

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

            var apiInstance = new AccessApi();
            var name = name_example;  // String | The name of the agent class to lookup

            try
            {
                // Returns the current client's access to the given agent class.
                AgentClassPermissions result = apiInstance.getAgentClassAccess(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getAgentClassAccess: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getAgentClassAccess(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccessApi->getAgentClassAccess: $@\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()
name = name_example # String | The name of the agent class to lookup

try: 
    # Returns the current client's access to the given agent class.
    api_response = api_instance.get_agent_class_access(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getAgentClassAccess: %s\n" % e)

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();
        String flowId = flowId_example; // String | The id of the flow to lookup
        try {
            AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getFlowAccess");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccessApi;

public class AccessApiExample {

    public static void main(String[] args) {
        AccessApi apiInstance = new AccessApi();
        String flowId = flowId_example; // String | The id of the flow to lookup
        try {
            AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getFlowAccess");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // The id of the flow to lookup

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

// Returns the current client's access to the given agent class.
[apiInstance getFlowAccessWith:flowId
              completionHandler: ^(AgentClassPermissions 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 flowId = flowId_example; // {{String}} The id of the flow to lookup

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

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

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

            var apiInstance = new AccessApi();
            var flowId = flowId_example;  // String | The id of the flow to lookup

            try
            {
                // Returns the current client's access to the given agent class.
                AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getFlowAccess: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAccessApi();
$flowId = flowId_example; // String | The id of the flow to lookup

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

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

my $api_instance = WWW::SwaggerClient::AccessApi->new();
my $flowId = flowId_example; # String | The id of the flow to lookup

eval { 
    my $result = $api_instance->getFlowAccess(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccessApi->getFlowAccess: $@\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()
flowId = flowId_example # String | The id of the flow to lookup

try: 
    # Returns the current client's access to the given agent class.
    api_response = api_instance.get_flow_access(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getFlowAccess: %s\n" % e)

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

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent manifest mapping to create
        try {
            AgentClassManifestConfig result = apiInstance.createAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#createAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent manifest mapping to create
        try {
            AgentClassManifestConfig result = apiInstance.createAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#createAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

AgentClassManifestConfig *body = ; // The agent manifest mapping to create

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

// Creates agent class to agent manifest mapping configuration.
[apiInstance createAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent manifest mapping to create

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

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var body = new AgentClassManifestConfig(); // AgentClassManifestConfig | The agent manifest mapping to create

            try
            {
                // Creates agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.createAgentManifestMapping(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.createAgentManifestMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$body = ; // AgentClassManifestConfig | The agent manifest mapping to create

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

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $body = WWW::SwaggerClient::Object::AgentClassManifestConfig->new(); # AgentClassManifestConfig | The agent manifest mapping to create

eval { 
    my $result = $api_instance->createAgentManifestMapping(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->createAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent manifest mapping to create

try: 
    # Creates agent class to agent manifest mapping configuration.
    api_response = api_instance.create_agent_manifest_mapping(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->createAgentManifestMapping: %s\n" % e)

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

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        String name = name_example; // String | The agent class name.
        try {
            AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#deleteAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        String name = name_example; // String | The agent class name.
        try {
            AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#deleteAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // The agent class name.

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

// Deletes an agent class to agent manifest mapping configuration.
[apiInstance deleteAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var name = name_example; // {{String}} The agent class name.

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

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var name = name_example;  // String | The agent class name.

            try
            {
                // Deletes an agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.deleteAgentManifestMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$name = name_example; // String | The agent class name.

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

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $name = name_example; # String | The agent class name.

eval { 
    my $result = $api_instance->deleteAgentManifestMapping(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->deleteAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
name = name_example # String | The agent class name.

try: 
    # Deletes an agent class to agent manifest mapping configuration.
    api_response = api_instance.delete_agent_manifest_mapping(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->deleteAgentManifestMapping: %s\n" % e)

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

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

public class AgentClassManifestConfigApiExample {

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

import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

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

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

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

// Returns the agent class to agent manifest mapping for a given agent class name.
[apiInstance getAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var name = name_example; // {{String}} The name of the agent class to retrieve mapping

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

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

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

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

            try
            {
                // Returns the agent class to agent manifest mapping for a given agent class name.
                AgentClassManifestConfig result = apiInstance.getAgentManifestMapping(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.getAgentManifestMapping: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getAgentManifestMapping(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->getAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
name = name_example # String | The name of the agent class to retrieve mapping

try: 
    # Returns the agent class to agent manifest mapping for a given agent class name.
    api_response = api_instance.get_agent_manifest_mapping(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->getAgentManifestMapping: %s\n" % e)

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

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

public class AgentClassManifestConfigApiExample {

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

import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

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

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

// Get all agent class to agent manifest mapping configurations 
[apiInstance getAgentManifestMappingsWithCompletionHandler: 
              ^(array[AgentClassManifestConfig] 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.AgentClassManifestConfigApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentManifestMappings(callback);

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

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

            var apiInstance = new AgentClassManifestConfigApi();

            try
            {
                // Get all agent class to agent manifest mapping configurations 
                array[AgentClassManifestConfig] result = apiInstance.getAgentManifestMappings();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.getAgentManifestMappings: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getAgentManifestMappings();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->getAgentManifestMappings: $@\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.AgentClassManifestConfigApi()

try: 
    # Get all agent class to agent manifest mapping configurations 
    api_response = api_instance.get_agent_manifest_mappings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->getAgentManifestMappings: %s\n" % e)

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

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update
        try {
            AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#updateAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update
        try {
            AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#updateAgentManifestMapping");
            e.printStackTrace();
        }
    }
}

AgentClassManifestConfig *body = ; // The agent class manifest mapping configuration to update

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

// Updates and existing agent class to agent manifest mapping configuration.
[apiInstance updateAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent class manifest mapping configuration to update

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

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var body = new AgentClassManifestConfig(); // AgentClassManifestConfig | The agent class manifest mapping configuration to update

            try
            {
                // Updates and existing agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.updateAgentManifestMapping: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update

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

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $body = WWW::SwaggerClient::Object::AgentClassManifestConfig->new(); # AgentClassManifestConfig | The agent class manifest mapping configuration to update

eval { 
    my $result = $api_instance->updateAgentManifestMapping(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->updateAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent class manifest mapping configuration to update

try: 
    # Updates and existing agent class to agent manifest mapping configuration.
    api_response = api_instance.update_agent_manifest_mapping(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->updateAgentManifestMapping: %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();
        String name = name_example; // String | The name of the class to work with
        try {
            ManifestDiff result = apiInstance.getManifestRefresh(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getManifestRefresh");
            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 work with
        try {
            ManifestDiff result = apiInstance.getManifestRefresh(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getManifestRefresh");
            e.printStackTrace();
        }
    }
}

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

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

// Get the potential impact of a possible manifest refresh on the given class
[apiInstance getManifestRefreshWith:name
              completionHandler: ^(ManifestDiff 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 work with

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

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

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

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

            try
            {
                // Get the potential impact of a possible manifest refresh on the given class
                ManifestDiff result = apiInstance.getManifestRefresh(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getManifestRefresh: " + 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 work with

try {
    $result = $api_instance->getManifestRefresh($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentClassesApi->getManifestRefresh: ', $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 work with

eval { 
    my $result = $api_instance->getManifestRefresh(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassesApi->getManifestRefresh: $@\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 work with

try: 
    # Get the potential impact of a possible manifest refresh on the given class
    api_response = api_instance.get_manifest_refresh(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getManifestRefresh: %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.AgentDeployerApi;

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
        String osArch = osArch_example; // String | The supported os version of the agent binary
        String agentVersion = agentVersion_example; // String | The version number of the agent binary
        try {
            apiInstance.binary(agentType, osArch, agentVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#binary");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
        String osArch = osArch_example; // String | The supported os version of the agent binary
        String agentVersion = agentVersion_example; // String | The version number of the agent binary
        try {
            apiInstance.binary(agentType, osArch, agentVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#binary");
            e.printStackTrace();
        }
    }
}

String *agentType = agentType_example; // The type of the agent binary(Java or CPP) (default to Java)
String *osArch = osArch_example; // The supported os version of the agent binary (default to Linux)
String *agentVersion = agentVersion_example; // The version number of the agent binary (default to 1.23.05)

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

// Retrieves the agent binary
[apiInstance binaryWith:agentType
    osArch:osArch
    agentVersion:agentVersion
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var agentType = agentType_example; // {{String}} The type of the agent binary(Java or CPP)
var osArch = osArch_example; // {{String}} The supported os version of the agent binary
var agentVersion = agentVersion_example; // {{String}} The version number of the agent binary

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.binary(agentType, osArch, agentVersion, callback);

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

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

            var apiInstance = new AgentDeployerApi();
            var agentType = agentType_example;  // String | The type of the agent binary(Java or CPP) (default to Java)
            var osArch = osArch_example;  // String | The supported os version of the agent binary (default to Linux)
            var agentVersion = agentVersion_example;  // String | The version number of the agent binary (default to 1.23.05)

            try
            {
                // Retrieves the agent binary
                apiInstance.binary(agentType, osArch, agentVersion);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.binary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
$osArch = osArch_example; // String | The supported os version of the agent binary
$agentVersion = agentVersion_example; // String | The version number of the agent binary

try {
    $api_instance->binary($agentType, $osArch, $agentVersion);
} catch (Exception $e) {
    echo 'Exception when calling AgentDeployerApi->binary: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentType = agentType_example; # String | The type of the agent binary(Java or CPP)
my $osArch = osArch_example; # String | The supported os version of the agent binary
my $agentVersion = agentVersion_example; # String | The version number of the agent binary

eval { 
    $api_instance->binary(agentType => $agentType, osArch => $osArch, agentVersion => $agentVersion);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->binary: $@\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.AgentDeployerApi()
agentType = agentType_example # String | The type of the agent binary(Java or CPP) (default to Java)
osArch = osArch_example # String | The supported os version of the agent binary (default to Linux)
agentVersion = agentVersion_example # String | The version number of the agent binary (default to 1.23.05)

try: 
    # Retrieves the agent binary
    api_instance.binary(agentType, osArch, agentVersion)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->binary: %s\n" % e)

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

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

public class AgentDeployerApiExample {

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

import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

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

AgentDeployerCommandGenerationRequest *body = ; //  (optional)

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

// Generates the curl / powershell command
[apiInstance generateCommandWith:body
              completionHandler: ^(AgentDeployerCommandResponse 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.AgentDeployerApi()
var opts = { 
  'body':  // {{AgentDeployerCommandGenerationRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateCommand(opts, callback);

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

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

            var apiInstance = new AgentDeployerApi();
            var body = new AgentDeployerCommandGenerationRequest(); // AgentDeployerCommandGenerationRequest |  (optional) 

            try
            {
                // Generates the curl / powershell command
                AgentDeployerCommandResponse result = apiInstance.generateCommand(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.generateCommand: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$body = ; // AgentDeployerCommandGenerationRequest | 

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

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

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

eval { 
    my $result = $api_instance->generateCommand(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->generateCommand: $@\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.AgentDeployerApi()
body =  # AgentDeployerCommandGenerationRequest |  (optional)

try: 
    # Generates the curl / powershell command
    api_response = api_instance.generate_command(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->generateCommand: %s\n" % e)

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

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentClass = agentClass_example; // String | The agent class
        try {
            ParametersResponse result = apiInstance.parameters(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#parameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentClass = agentClass_example; // String | The agent class
        try {
            ParametersResponse result = apiInstance.parameters(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#parameters");
            e.printStackTrace();
        }
    }
}

String *agentClass = agentClass_example; // The agent class

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

// Retrieves the available parameters for the one liner command generation
[apiInstance parametersWith:agentClass
              completionHandler: ^(ParametersResponse 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.AgentDeployerApi()
var agentClass = agentClass_example; // {{String}} The agent class

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

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

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

            var apiInstance = new AgentDeployerApi();
            var agentClass = agentClass_example;  // String | The agent class

            try
            {
                // Retrieves the available parameters for the one liner command generation
                ParametersResponse result = apiInstance.parameters(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.parameters: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentClass = agentClass_example; // String | The agent class

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

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentClass = agentClass_example; # String | The agent class

eval { 
    my $result = $api_instance->parameters(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->parameters: $@\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.AgentDeployerApi()
agentClass = agentClass_example # String | The agent class

try: 
    # Retrieves the available parameters for the one liner command generation
    api_response = api_instance.parameters(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->parameters: %s\n" % e)

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

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        ScriptGenerationRequest body = ; // ScriptGenerationRequest | Agent deployer script api model
        try {
            apiInstance.script(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#script");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        ScriptGenerationRequest body = ; // ScriptGenerationRequest | Agent deployer script api model
        try {
            apiInstance.script(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#script");
            e.printStackTrace();
        }
    }
}

ScriptGenerationRequest *body = ; // Agent deployer script api model (optional)

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

// Retrieves the deployer script
[apiInstance scriptWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var opts = { 
  'body':  // {{ScriptGenerationRequest}} Agent deployer script api model
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.script(opts, callback);

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

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

            var apiInstance = new AgentDeployerApi();
            var body = new ScriptGenerationRequest(); // ScriptGenerationRequest | Agent deployer script api model (optional) 

            try
            {
                // Retrieves the deployer script
                apiInstance.script(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.script: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$body = ; // ScriptGenerationRequest | Agent deployer script api model

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

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $body = WWW::SwaggerClient::Object::ScriptGenerationRequest->new(); # ScriptGenerationRequest | Agent deployer script api model

eval { 
    $api_instance->script(body => $body);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->script: $@\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.AgentDeployerApi()
body =  # ScriptGenerationRequest | Agent deployer script api model (optional)

try: 
    # Retrieves the deployer script
    api_instance.script(body=body)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->script: %s\n" % e)

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

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentId = agentId_example; // String | The agent identifier
        String agentClass = agentClass_example; // String | The agent class
        String agentType = agentType_example; // String | The agent type
        try {
            StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#securityBundle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentId = agentId_example; // String | The agent identifier
        String agentClass = agentClass_example; // String | The agent class
        String agentType = agentType_example; // String | The agent type
        try {
            StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#securityBundle");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // The agent identifier
String *agentClass = agentClass_example; // The agent class
String *agentType = agentType_example; // The agent type

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

// Retrieves security for the given agent
[apiInstance securityBundleWith:agentId
    agentClass:agentClass
    agentType:agentType
              completionHandler: ^(StreamingResponseBody 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.AgentDeployerApi()
var agentId = agentId_example; // {{String}} The agent identifier
var agentClass = agentClass_example; // {{String}} The agent class
var agentType = agentType_example; // {{String}} The agent type

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

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

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

            var apiInstance = new AgentDeployerApi();
            var agentId = agentId_example;  // String | The agent identifier
            var agentClass = agentClass_example;  // String | The agent class
            var agentType = agentType_example;  // String | The agent type

            try
            {
                // Retrieves security for the given agent
                StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.securityBundle: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentId = agentId_example; // String | The agent identifier
$agentClass = agentClass_example; // String | The agent class
$agentType = agentType_example; // String | The agent type

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

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentId = agentId_example; # String | The agent identifier
my $agentClass = agentClass_example; # String | The agent class
my $agentType = agentType_example; # String | The agent type

eval { 
    my $result = $api_instance->securityBundle(agentId => $agentId, agentClass => $agentClass, agentType => $agentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->securityBundle: $@\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.AgentDeployerApi()
agentId = agentId_example # String | The agent identifier
agentClass = agentClass_example # String | The agent class
agentType = agentType_example # String | The agent type

try: 
    # Retrieves security for the given agent
    api_response = api_instance.security_bundle(agentId, agentClass, agentType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->securityBundle: %s\n" % e)

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

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

public class AgentManagerApiExample {

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

import io.swagger.client.api.AgentManagerApi;

public class AgentManagerApiExample {

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

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

// Gets the available attributes for the agent manager table
[apiInstance attributesWithCompletionHandler: 
              ^(AttributesResponse 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.AgentManagerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.attributes(callback);

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

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

            var apiInstance = new AgentManagerApi();

            try
            {
                // Gets the available attributes for the agent manager table
                AttributesResponse result = apiInstance.attributes();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.attributes: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->attributes();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManagerApi->attributes: $@\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.AgentManagerApi()

try: 
    # Gets the available attributes for the agent manager table
    api_response = api_instance.attributes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->attributes: %s\n" % e)

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

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

public class AgentManagerApiExample {

    public static void main(String[] args) {
        
        AgentManagerApi apiInstance = new AgentManagerApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        array[String] sort = ; // array[String] | Sorting by in the following format: field:DESC
        array[String] filter = ; // array[String] | Filter by in the following format: field:operator:value
        try {
            AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#getListing");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManagerApi;

public class AgentManagerApiExample {

    public static void main(String[] args) {
        AgentManagerApi apiInstance = new AgentManagerApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        array[String] sort = ; // array[String] | Sorting by in the following format: field:DESC
        array[String] filter = ; // array[String] | Filter by in the following format: field:operator:value
        try {
            AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#getListing");
            e.printStackTrace();
        }
    }
}

Integer *pageNum = 56; // The zero-indexed page number to retrieve. Default is 0. (optional)
Integer *rows = 56; // The number of results to include per page. Default is 10. (optional)
array[String] *sort = ; // Sorting by in the following format: field:DESC (optional)
array[String] *filter = ; // Filter by in the following format: field:operator:value (optional)

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

// Agent manager listing
[apiInstance getListingWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(AgentListingResponse 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.AgentManagerApi()
var opts = { 
  'pageNum': 56, // {{Integer}} The zero-indexed page number to retrieve. Default is 0.
  'rows': 56, // {{Integer}} The number of results to include per page. Default is 10.
  'sort': , // {{array[String]}} Sorting by in the following format: field:DESC
  'filter':  // {{array[String]}} Filter by in the following format: field:operator:value
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getListing(opts, callback);

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

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

            var apiInstance = new AgentManagerApi();
            var pageNum = 56;  // Integer | The zero-indexed page number to retrieve. Default is 0. (optional) 
            var rows = 56;  // Integer | The number of results to include per page. Default is 10. (optional) 
            var sort = new array[String](); // array[String] | Sorting by in the following format: field:DESC (optional) 
            var filter = new array[String](); // array[String] | Filter by in the following format: field:operator:value (optional) 

            try
            {
                // Agent manager listing
                AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.getListing: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManagerApi();
$pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
$rows = 56; // Integer | The number of results to include per page. Default is 10.
$sort = ; // array[String] | Sorting by in the following format: field:DESC
$filter = ; // array[String] | Filter by in the following format: field:operator:value

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

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

my $api_instance = WWW::SwaggerClient::AgentManagerApi->new();
my $pageNum = 56; # Integer | The zero-indexed page number to retrieve. Default is 0.
my $rows = 56; # Integer | The number of results to include per page. Default is 10.
my $sort = []; # array[String] | Sorting by in the following format: field:DESC
my $filter = []; # array[String] | Filter by in the following format: field:operator:value

eval { 
    my $result = $api_instance->getListing(pageNum => $pageNum, rows => $rows, sort => $sort, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManagerApi->getListing: $@\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.AgentManagerApi()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
sort =  # array[String] | Sorting by in the following format: field:DESC (optional)
filter =  # array[String] | Filter by in the following format: field:operator:value (optional)

try: 
    # Agent manager listing
    api_response = api_instance.get_listing(pageNum=pageNum, rows=rows, sort=sort, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->getListing: %s\n" % e)

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

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

public class AgentManagerApiExample {

    public static void main(String[] args) {
        
        AgentManagerApi apiInstance = new AgentManagerApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            map['String', 'String'] result = apiInstance.properties(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#properties");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentManagerApi;

public class AgentManagerApiExample {

    public static void main(String[] args) {
        AgentManagerApi apiInstance = new AgentManagerApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            map['String', 'String'] result = apiInstance.properties(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#properties");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // The id of the agent

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

// Gets the current property names and values for the agent
[apiInstance propertiesWith:agentId
              completionHandler: ^(map['String', '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.AgentManagerApi()
var agentId = agentId_example; // {{String}} The id of the agent

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

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

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

            var apiInstance = new AgentManagerApi();
            var agentId = agentId_example;  // String | The id of the agent

            try
            {
                // Gets the current property names and values for the agent
                map['String', 'String'] result = apiInstance.properties(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.properties: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentManagerApi();
$agentId = agentId_example; // String | The id of the agent

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

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

my $api_instance = WWW::SwaggerClient::AgentManagerApi->new();
my $agentId = agentId_example; # String | The id of the agent

eval { 
    my $result = $api_instance->properties(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManagerApi->properties: $@\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.AgentManagerApi()
agentId = agentId_example # String | The id of the agent

try: 
    # Gets the current property names and values for the agent
    api_response = api_instance.properties(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->properties: %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();
        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 id = id_example; // String | The identifier of the agent to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(id);
            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 id = id_example; // String | The identifier of the agent to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgentParameters");
            e.printStackTrace();
        }
    }
}

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

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

// Delete an instance specific parameter context
[apiInstance deleteAgentParametersWith: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 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(id, 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 id = id_example;  // String | The identifier of the agent to delete its parameter context

            try
            {
                // Delete an instance specific parameter context
                ParameterContext result = apiInstance.deleteAgentParameters(id);
                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();
$id = id_example; // String | The identifier of the agent to delete its parameter context

try {
    $result = $api_instance->deleteAgentParameters($id);
    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 $id = id_example; # String | The identifier of the agent to delete its parameter context

eval { 
    my $result = $api_instance->deleteAgentParameters(id => $id);
    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()
id = id_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(id)
    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();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        String agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
        String state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.
        try {
            AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentsPage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        String agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
        String state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.
        try {
            AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentsPage");
            e.printStackTrace();
        }
    }
}

Integer *pageNum = 56; // The zero-indexed page number to retrieve. Default is 0. (optional)
Integer *rows = 56; // The number of results to include per page. Default is 10. (optional)
String *agentClass = agentClass_example; // Filter results by agent class. If not specified, this filter is not applied. (optional)
String *state = state_example; // Filter results by agent state. If not specified, this filter is not applied. (optional)

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

// Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
[apiInstance getAgentsPageWith:pageNum
    rows:rows
    agentClass:agentClass
    state:state
              completionHandler: ^(AgentList 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 = { 
  'pageNum': 56, // {{Integer}} The zero-indexed page number to retrieve. Default is 0.
  'rows': 56, // {{Integer}} The number of results to include per page. Default is 10.
  'agentClass': agentClass_example, // {{String}} Filter results by agent class. If not specified, this filter is not applied.
  'state': state_example // {{String}} Filter results by agent state. If not specified, this filter is not applied.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentsPage(opts, callback);

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

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

            var apiInstance = new AgentsApi();
            var pageNum = 56;  // Integer | The zero-indexed page number to retrieve. Default is 0. (optional) 
            var rows = 56;  // Integer | The number of results to include per page. Default is 10. (optional) 
            var agentClass = agentClass_example;  // String | Filter results by agent class. If not specified, this filter is not applied. (optional) 
            var state = state_example;  // String | Filter results by agent state. If not specified, this filter is not applied. (optional) 

            try
            {
                // Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
                AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgentsPage: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAgentsApi();
$pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
$rows = 56; // Integer | The number of results to include per page. Default is 10.
$agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
$state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.

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

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $pageNum = 56; # Integer | The zero-indexed page number to retrieve. Default is 0.
my $rows = 56; # Integer | The number of results to include per page. Default is 10.
my $agentClass = agentClass_example; # String | Filter results by agent class. If not specified, this filter is not applied.
my $state = state_example; # String | Filter results by agent state. If not specified, this filter is not applied.

eval { 
    my $result = $api_instance->getAgentsPage(pageNum => $pageNum, rows => $rows, agentClass => $agentClass, state => $state);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->getAgentsPage: $@\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()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
agentClass = agentClass_example # String | Filter results by agent class. If not specified, this filter is not applied. (optional)
state = state_example # String | Filter results by agent state. If not specified, this filter is not applied. (optional)

try: 
    # Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
    api_response = api_instance.get_agents_page(pageNum=pageNum, rows=rows, agentClass=agentClass, state=state)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgentsPage: %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 update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to update
        try {
            ParameterContext result = apiInstance.updateAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#updateAgentParameters");
            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 update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to update
        try {
            ParameterContext result = apiInstance.updateAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#updateAgentParameters");
            e.printStackTrace();
        }
    }
}

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

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

// Update a set of Parameters to use with this agent.
[apiInstance updateAgentParametersWith: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 update parameters of
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the agent to update
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAgentParameters(id, opts, callback);

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

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

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

            try
            {
                // Update a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.updateAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.updateAgentParameters: " + 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 update parameters of
$body = ; // array[Parameter] | The metadata of the agent to update

try {
    $result = $api_instance->updateAgentParameters($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentsApi->updateAgentParameters: ', $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 update parameters of
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to update

eval { 
    my $result = $api_instance->updateAgentParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->updateAgentParameters: $@\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 update parameters of
body =  # array[Parameter] | The metadata of the agent to update (optional)

try: 
    # Update a set of Parameters to use with this agent.
    api_response = api_instance.update_agent_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->updateAgentParameters: %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.C2ProtocolCallbackApi;

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

public class C2ProtocolCallbackApiExample {

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

import io.swagger.client.api.C2ProtocolCallbackApi;

public class C2ProtocolCallbackApiExample {

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

String *id = id_example; // The id of an asset to retrieve

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

// An endpoint for a MiNiFi Agent to fetch the requested asset from
[apiInstance fetchAssetDataWith:id
              completionHandler: ^(ByteArrayResource 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.C2ProtocolCallbackApi()
var id = id_example; // {{String}} The id of an asset to retrieve

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

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

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

            var apiInstance = new C2ProtocolCallbackApi();
            var id = id_example;  // String | The id of an asset to retrieve

            try
            {
                // An endpoint for a MiNiFi Agent to fetch the requested asset from
                ByteArrayResource result = apiInstance.fetchAssetData(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.fetchAssetData: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$id = id_example; // String | The id of an asset to retrieve

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

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $id = id_example; # String | The id of an asset to retrieve

eval { 
    my $result = $api_instance->fetchAssetData(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling C2ProtocolCallbackApi->fetchAssetData: $@\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.C2ProtocolCallbackApi()
id = id_example # String | The id of an asset to retrieve

try: 
    # An endpoint for a MiNiFi Agent to fetch the requested asset from
    api_response = api_instance.fetch_asset_data(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->fetchAssetData: %s\n" % e)

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

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

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
        try {
            'String' result = apiInstance.fetchFlowContent(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#fetchFlowContent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ProtocolCallbackApi;

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
        try {
            'String' result = apiInstance.fetchFlowContent(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#fetchFlowContent");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of a flow to retrieve
String *aid = aid_example; // The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional)

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

// Get a flow definition by id with a format requested in the accept header
[apiInstance fetchFlowContentWith: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.C2ProtocolCallbackApi()
var id = id_example; // {{String}} The id of a flow to retrieve
var opts = { 
  'aid': aid_example // {{String}} The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fetchFlowContent(id, opts, callback);

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

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

            var apiInstance = new C2ProtocolCallbackApi();
            var id = id_example;  // String | The id of a flow to retrieve
            var aid = aid_example;  // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional) 

            try
            {
                // Get a flow definition by id with a format requested in the accept header
                'String' result = apiInstance.fetchFlowContent(id, aid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.fetchFlowContent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$id = id_example; // String | The id of a flow to retrieve
$aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.

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

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $id = id_example; # String | The id of a flow to retrieve
my $aid = aid_example; # String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.

eval { 
    my $result = $api_instance->fetchFlowContent(id => $id, aid => $aid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling C2ProtocolCallbackApi->fetchFlowContent: $@\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.C2ProtocolCallbackApi()
id = id_example # String | The id of a flow to retrieve
aid = aid_example # String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional)

try: 
    # Get a flow definition by id with a format requested in the accept header
    api_response = api_instance.fetch_flow_content(id, aid=aid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->fetchFlowContent: %s\n" % e)

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

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

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        byte[] file = file_example; // byte[] | 
        String id = id_example; // String | The identifier of the transfer data entry to attach the file to
        try {
            apiInstance.uploadTransferData(file, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#uploadTransferData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.C2ProtocolCallbackApi;

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        byte[] file = file_example; // byte[] | 
        String id = id_example; // String | The identifier of the transfer data entry to attach the file to
        try {
            apiInstance.uploadTransferData(file, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#uploadTransferData");
            e.printStackTrace();
        }
    }
}

byte[] *file = file_example; // 
String *id = id_example; // The identifier of the transfer data entry to attach the file to

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

// Transfers file from C2 client to C2 server
[apiInstance uploadTransferDataWith:file
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolCallbackApi()
var file = file_example; // {{byte[]}} 
var id = id_example; // {{String}} The identifier of the transfer data entry to attach the file to

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

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

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

            var apiInstance = new C2ProtocolCallbackApi();
            var file = file_example;  // byte[] | 
            var id = id_example;  // String | The identifier of the transfer data entry to attach the file to

            try
            {
                // Transfers file from C2 client to C2 server
                apiInstance.uploadTransferData(file, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.uploadTransferData: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$file = file_example; // byte[] | 
$id = id_example; // String | The identifier of the transfer data entry to attach the file to

try {
    $api_instance->uploadTransferData($file, $id);
} catch (Exception $e) {
    echo 'Exception when calling C2ProtocolCallbackApi->uploadTransferData: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $file = file_example; # byte[] | 
my $id = id_example; # String | The identifier of the transfer data entry to attach the file to

eval { 
    $api_instance->uploadTransferData(file => $file, id => $id);
};
if ($@) {
    warn "Exception when calling C2ProtocolCallbackApi->uploadTransferData: $@\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.C2ProtocolCallbackApi()
file = file_example # byte[] | 
id = id_example # String | The identifier of the transfer data entry to attach the file to

try: 
    # Transfers file from C2 client to C2 server
    api_instance.upload_transfer_data(file, id)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->uploadTransferData: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The identifier of the agent the operation should be executed on
        try {
            Operation result = apiInstance.createDebugOperation(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createDebugOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The identifier of the agent the operation should be executed on
        try {
            Operation result = apiInstance.createDebugOperation(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createDebugOperation");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // The identifier of the agent the operation should be executed on

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

// Submit a debug operation targeting a MiNiFi agent.
[apiInstance createDebugOperationWith:agentId
              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.CommandsApi()
var agentId = agentId_example; // {{String}} The identifier of the agent the operation should be executed on

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

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

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

            var apiInstance = new CommandsApi();
            var agentId = agentId_example;  // String | The identifier of the agent the operation should be executed on

            try
            {
                // Submit a debug operation targeting a MiNiFi agent.
                Operation result = apiInstance.createDebugOperation(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createDebugOperation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentId = agentId_example; // String | The identifier of the agent the operation should be executed on

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

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentId = agentId_example; # String | The identifier of the agent the operation should be executed on

eval { 
    my $result = $api_instance->createDebugOperation(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createDebugOperation: $@\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.CommandsApi()
agentId = agentId_example # String | The identifier of the agent the operation should be executed on

try: 
    # Submit a debug operation targeting a MiNiFi agent.
    api_response = api_instance.create_debug_operation(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createDebugOperation: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        PropertyUpdateCommandRequest body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details
        try {
            PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createPropertyUpdateOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        PropertyUpdateCommandRequest body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details
        try {
            PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createPropertyUpdateOperation");
            e.printStackTrace();
        }
    }
}

PropertyUpdateCommandRequest *body = ; // The update request payload with agentClass and properties details

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

// Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
[apiInstance createPropertyUpdateOperationWith:body
              completionHandler: ^(PropertyUpdateCommandResponse 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.CommandsApi()
var body = ; // {{PropertyUpdateCommandRequest}} The update request payload with agentClass and properties details

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

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

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

            var apiInstance = new CommandsApi();
            var body = new PropertyUpdateCommandRequest(); // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

            try
            {
                // Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
                PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createPropertyUpdateOperation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCommandsApi();
$body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

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

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $body = WWW::SwaggerClient::Object::PropertyUpdateCommandRequest->new(); # PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

eval { 
    my $result = $api_instance->createPropertyUpdateOperation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createPropertyUpdateOperation: $@\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.CommandsApi()
body =  # PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

try: 
    # Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
    api_response = api_instance.create_property_update_operation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createPropertyUpdateOperation: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        AssetUpdateCommandRequest body = ; // AssetUpdateCommandRequest | The request object of the asset update
        String agentClass = agentClass_example; // String | The class of the agent the operation should be executed on
        try {
            AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createUpdateAssetOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        AssetUpdateCommandRequest body = ; // AssetUpdateCommandRequest | The request object of the asset update
        String agentClass = agentClass_example; // String | The class of the agent the operation should be executed on
        try {
            AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createUpdateAssetOperation");
            e.printStackTrace();
        }
    }
}

AssetUpdateCommandRequest *body = ; // The request object of the asset update
String *agentClass = agentClass_example; // The class of the agent the operation should be executed on

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

// Submit an asset update operation targeting a MiNiFi agent class. [BETA]
[apiInstance createUpdateAssetOperationWith:body
    agentClass:agentClass
              completionHandler: ^(AssetUpdateCommandResponse 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.CommandsApi()
var body = ; // {{AssetUpdateCommandRequest}} The request object of the asset update
var agentClass = agentClass_example; // {{String}} The class of the agent the operation should be executed on

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

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

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

            var apiInstance = new CommandsApi();
            var body = new AssetUpdateCommandRequest(); // AssetUpdateCommandRequest | The request object of the asset update
            var agentClass = agentClass_example;  // String | The class of the agent the operation should be executed on

            try
            {
                // Submit an asset update operation targeting a MiNiFi agent class. [BETA]
                AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createUpdateAssetOperation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCommandsApi();
$body = ; // AssetUpdateCommandRequest | The request object of the asset update
$agentClass = agentClass_example; // String | The class of the agent the operation should be executed on

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

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $body = WWW::SwaggerClient::Object::AssetUpdateCommandRequest->new(); # AssetUpdateCommandRequest | The request object of the asset update
my $agentClass = agentClass_example; # String | The class of the agent the operation should be executed on

eval { 
    my $result = $api_instance->createUpdateAssetOperation(body => $body, agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createUpdateAssetOperation: $@\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.CommandsApi()
body =  # AssetUpdateCommandRequest | The request object of the asset update
agentClass = agentClass_example # String | The class of the agent the operation should be executed on

try: 
    # Submit an asset update operation targeting a MiNiFi agent class. [BETA]
    api_response = api_instance.create_update_asset_operation(body, agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createUpdateAssetOperation: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getAgentClassPropertyNamesAndValidatorsForUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getAgentClassPropertyNamesAndValidatorsForUpdate");
            e.printStackTrace();
        }
    }
}

String *agentClass = agentClass_example; // The name of the agent class

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

// Retrieve the available property names to be updated under the given agent class.
[apiInstance getAgentClassPropertyNamesAndValidatorsForUpdateWith:agentClass
              completionHandler: ^(AgentPropertyValidatorResponse 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.CommandsApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class

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

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

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

            var apiInstance = new CommandsApi();
            var agentClass = agentClass_example;  // String | The name of the agent class

            try
            {
                // Retrieve the available property names to be updated under the given agent class.
                AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.getAgentClassPropertyNamesAndValidatorsForUpdate: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentClass = agentClass_example; // String | The name of the agent class

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

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class

eval { 
    my $result = $api_instance->getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->getAgentClassPropertyNamesAndValidatorsForUpdate: $@\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.CommandsApi()
agentClass = agentClass_example # String | The name of the agent class

try: 
    # Retrieve the available property names to be updated under the given agent class.
    api_response = api_instance.get_agent_class_property_names_and_validators_for_update(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->getAgentClassPropertyNamesAndValidatorsForUpdate: %s\n" % e)

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The agent identifier
        Integer rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
        try {
            CommandListingResponse result = apiInstance.getCommands(agentId, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getCommands");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The agent identifier
        Integer rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
        try {
            CommandListingResponse result = apiInstance.getCommands(agentId, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getCommands");
            e.printStackTrace();
        }
    }
}

String *agentId = agentId_example; // The agent identifier
Integer *rows = 56; // The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional)

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

// Returns the previous commands for the given agent
[apiInstance getCommandsWith:agentId
    rows:rows
              completionHandler: ^(CommandListingResponse 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.CommandsApi()
var agentId = agentId_example; // {{String}} The agent identifier
var opts = { 
  'rows': 56 // {{Integer}} The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCommands(agentId, opts, callback);

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

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

            var apiInstance = new CommandsApi();
            var agentId = agentId_example;  // String | The agent identifier
            var rows = 56;  // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional) 

            try
            {
                // Returns the previous commands for the given agent
                CommandListingResponse result = apiInstance.getCommands(agentId, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.getCommands: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentId = agentId_example; // String | The agent identifier
$rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.

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

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentId = agentId_example; # String | The agent identifier
my $rows = 56; # Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.

eval { 
    my $result = $api_instance->getCommands(agentId => $agentId, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->getCommands: $@\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.CommandsApi()
agentId = agentId_example # String | The agent identifier
rows = 56 # Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional)

try: 
    # Returns the previous commands for the given agent
    api_response = api_instance.get_commands(agentId, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->getCommands: %s\n" % e)

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

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

public class DiagnosticApiExample {

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

import io.swagger.client.api.DiagnosticApi;

public class DiagnosticApiExample {

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

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

// Returns the current diagnostic bundle
[apiInstance diagnosticBundleWithCompletionHandler: 
              ^(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.DiagnosticApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.diagnosticBundle(callback);

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

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

            var apiInstance = new DiagnosticApi();

            try
            {
                // Returns the current diagnostic bundle
                AgentClass result = apiInstance.diagnosticBundle();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DiagnosticApi.diagnosticBundle: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->diagnosticBundle();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiagnosticApi->diagnosticBundle: $@\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.DiagnosticApi()

try: 
    # Returns the current diagnostic bundle
    api_response = api_instance.diagnostic_bundle()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiagnosticApi->diagnosticBundle: %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 {
            EventList 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 {
            EventList 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. Page numbers are zero-indexed.
[apiInstance getEventsWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(EventList 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. Page numbers are zero-indexed.
                EventList 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. Page numbers are zero-indexed.
    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();
        String agentClassName = agentClassName_example; // String | 
        try {
            ExportableFlow result = apiInstance.exportFlowByAgentClass(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#exportFlowByAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

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

String *agentClassName = agentClassName_example; // 

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

// Export flow content, parameters and agent manifest for a given agent class
[apiInstance exportFlowByAgentClassWith:agentClassName
              completionHandler: ^(ExportableFlow 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 agentClassName = agentClassName_example; // {{String}} 

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

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

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

            var apiInstance = new FlowDesignerApi();
            var agentClassName = agentClassName_example;  // String | 

            try
            {
                // Export flow content, parameters and agent manifest for a given agent class
                ExportableFlow result = apiInstance.exportFlowByAgentClass(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.exportFlowByAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$agentClassName = agentClassName_example; // String | 

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

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

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

eval { 
    my $result = $api_instance->exportFlowByAgentClass(agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->exportFlowByAgentClass: $@\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()
agentClassName = agentClassName_example # String | 

try: 
    # Export flow content, parameters and agent manifest for a given agent class
    api_response = api_instance.export_flow_by_agent_class(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->exportFlowByAgentClass: %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();
        try {
            ClientIdParameter result = apiInstance.getClientIdentifier();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientIdentifier");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

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

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

// Gets a client id to use with the designer endpoints
[apiInstance getClientIdentifierWithCompletionHandler: 
              ^(ClientIdParameter 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.getClientIdentifier(callback);

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

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

            var apiInstance = new FlowDesignerApi();

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

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

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

try {
    $result = $api_instance->getClientIdentifier();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getClientIdentifier: ', $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->getClientIdentifier();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getClientIdentifier: $@\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_identifier()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getClientIdentifier: %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 {
            FDControllerServiceList 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 {
            FDControllerServiceList 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: ^(FDControllerServiceList 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
                FDControllerServiceList 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 {
            FDFlowEventList 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 {
            FDFlowEventList 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: ^(FDFlowEventList 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
                FDFlowEventList 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 {
            FDFlowSummaryList 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 {
            FDFlowSummaryList 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: 
              ^(FDFlowSummaryList 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
                FDFlowSummaryList 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 {
            ListFDFlowMetadata 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 {
            ListFDFlowMetadata 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: 
              ^(ListFDFlowMetadata 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
                ListFDFlowMetadata 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();
        ExportableFlow body = ; // ExportableFlow | The flow details.
        String agentClassName = agentClassName_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#importFlowByAgentClass");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        ExportableFlow body = ; // ExportableFlow | The flow details.
        String agentClassName = agentClassName_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#importFlowByAgentClass");
            e.printStackTrace();
        }
    }
}

ExportableFlow *body = ; // The flow details.
String *agentClassName = agentClassName_example; // 

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

// Persists the given flow in the given agent class
[apiInstance importFlowByAgentClassWith:body
    agentClassName:agentClassName
              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 body = ; // {{ExportableFlow}} The flow details.
var agentClassName = agentClassName_example; // {{String}} 

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

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new ExportableFlow(); // ExportableFlow | The flow details.
            var agentClassName = agentClassName_example;  // String | 

            try
            {
                // Persists the given flow in the given agent class
                FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.importFlowByAgentClass: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // ExportableFlow | The flow details.
$agentClassName = agentClassName_example; // String | 

try {
    $result = $api_instance->importFlowByAgentClass($body, $agentClassName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->importFlowByAgentClass: ', $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::ExportableFlow->new(); # ExportableFlow | The flow details.
my $agentClassName = agentClassName_example; # String | 

eval { 
    my $result = $api_instance->importFlowByAgentClass(body => $body, agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->importFlowByAgentClass: $@\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 =  # ExportableFlow | The flow details.
agentClassName = agentClassName_example # String | 

try: 
    # Persists the given flow in the given agent class
    api_response = api_instance.import_flow_by_agent_class(body, agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->importFlowByAgentClass: %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
        Boolean forcePublish = true; // Boolean | Publish the flow even if it has validation errors
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
            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
        Boolean forcePublish = true; // Boolean | Publish the flow even if it has validation errors
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
            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)
Boolean *forcePublish = true; // Publish the flow even if it has validation errors (optional)

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

// Publishes the current state of the flow
[apiInstance publishFlowWith:flowId
    body:body
    forcePublish:forcePublish
              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
  'forcePublish': true // {{Boolean}} Publish the flow even if it has validation errors
};
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) 
            var forcePublish = true;  // Boolean | Publish the flow even if it has validation errors (optional) 

            try
            {
                // Publishes the current state of the flow
                FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
                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
$forcePublish = true; // Boolean | Publish the flow even if it has validation errors

try {
    $result = $api_instance->publishFlow($flowId, $body, $forcePublish);
    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
my $forcePublish = true; # Boolean | Publish the flow even if it has validation errors

eval { 
    my $result = $api_instance->publishFlow(flowId => $flowId, body => $body, forcePublish => $forcePublish);
    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)
forcePublish = true # Boolean | Publish the flow even if it has validation errors (optional)

try: 
    # Publishes the current state of the flow
    api_response = api_instance.publish_flow(flowId, body=body, forcePublish=forcePublish)
    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 agentClass = agentClass_example; // String | 
        try {
            apiInstance.refreshFlowManifest(agentClass);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#refreshFlowManifest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

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

String *agentClass = agentClass_example; // 

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

// Refreshes the existing flow based on the latest manifest available under that Agent Class
[apiInstance refreshFlowManifestWith:agentClass
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var agentClass = agentClass_example; // {{String}} 

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

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

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

            var apiInstance = new FlowDesignerApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Refreshes the existing flow based on the latest manifest available under that Agent Class
                apiInstance.refreshFlowManifest(agentClass);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.refreshFlowManifest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$agentClass = agentClass_example; // String | 

try {
    $api_instance->refreshFlowManifest($agentClass);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->refreshFlowManifest: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->refreshFlowManifest(agentClass => $agentClass);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->refreshFlowManifest: $@\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()
agentClass = agentClass_example # String | 

try: 
    # Refreshes the existing flow based on the latest manifest available under that Agent Class
    api_instance.refresh_flow_manifest(agentClass)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->refreshFlowManifest: %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)