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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        ConnectorOffsets connectorOffsets = ; // ConnectorOffsets | 

        try {
            apiInstance.alterConnectorOffsets(connector, connectorOffsets);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#alterConnectorOffsets");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final ConnectorOffsets connectorOffsets = new ConnectorOffsets(); // ConnectorOffsets | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        ConnectorOffsets connectorOffsets = ; // ConnectorOffsets | 

        try {
            apiInstance.alterConnectorOffsets(connector, connectorOffsets);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#alterConnectorOffsets");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
ConnectorOffsets *connectorOffsets = ; //  (optional)

// Alter the offsets for the specified connector
[apiInstance alterConnectorOffsetsWith:connector
    connectorOffsets:connectorOffsets
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var opts = {
  'connectorOffsets':  // {ConnectorOffsets} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var connectorOffsets = new ConnectorOffsets(); // ConnectorOffsets |  (optional) 

            try {
                // Alter the offsets for the specified connector
                apiInstance.alterConnectorOffsets(connector, connectorOffsets);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.alterConnectorOffsets: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$connectorOffsets = ; // ConnectorOffsets | 

try {
    $api_instance->alterConnectorOffsets($connector, $connectorOffsets);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->alterConnectorOffsets: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $connectorOffsets = WWW::OPenAPIClient::Object::ConnectorOffsets->new(); # ConnectorOffsets | 

eval {
    $api_instance->alterConnectorOffsets(connector => $connector, connectorOffsets => $connectorOffsets);
};
if ($@) {
    warn "Exception when calling DefaultApi->alterConnectorOffsets: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
connectorOffsets =  # ConnectorOffsets |  (optional)

try:
    # Alter the offsets for the specified connector
    api_instance.alter_connector_offsets(connector, connectorOffsets=connectorOffsets)
except ApiException as e:
    print("Exception when calling DefaultApi->alterConnectorOffsets: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let connectorOffsets = ; // ConnectorOffsets

    let mut context = DefaultApi::Context::default();
    let result = client.alterConnectorOffsets(connector, connectorOffsets, &context).wait();

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

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

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

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

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

        try {
            apiInstance.createConnector(createConnectorRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateConnectorRequest createConnectorRequest = new CreateConnectorRequest(); // CreateConnectorRequest | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.createConnector(createConnectorRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createConnector");
            e.printStackTrace();
        }
    }
}

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

// Create a new connector
[apiInstance createConnectorWith:createConnectorRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var opts = {
  'createConnectorRequest':  // {CreateConnectorRequest} 
};

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

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

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

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

            try {
                // Create a new connector
                apiInstance.createConnector(createConnectorRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createConnector: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->createConnector($createConnectorRequest);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->createConnector(createConnectorRequest => $createConnectorRequest);
};
if ($@) {
    warn "Exception when calling DefaultApi->createConnector: $@\n";
}

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

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

try:
    # Create a new connector
    api_instance.create_connector(createConnectorRequest=createConnectorRequest)
except ApiException as e:
    print("Exception when calling DefaultApi->createConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let createConnectorRequest = ; // CreateConnectorRequest

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.destroyConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.destroyConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Delete the specified connector
[apiInstance destroyConnectorWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Delete the specified connector
                apiInstance.destroyConnector(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.destroyConnector: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->destroyConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->destroyConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->destroyConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->destroyConnector: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Delete the specified connector
    api_instance.destroy_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->destroyConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Get the details for the specified connector
[apiInstance getConnectorWith:connector
              completionHandler: ^(ConnectorInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Get the details for the specified connector
                ConnectorInfo result = apiInstance.getConnector(connector);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getConnector: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Get the details for the specified connector
    api_response = api_instance.get_connector(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.getConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.getConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Get the list of topics actively used by the specified connector
[apiInstance getConnectorActiveTopicsWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Get the list of topics actively used by the specified connector
                apiInstance.getConnectorActiveTopics(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getConnectorActiveTopics: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->getConnectorActiveTopics($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getConnectorActiveTopics: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->getConnectorActiveTopics(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->getConnectorActiveTopics: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Get the list of topics actively used by the specified connector
    api_instance.get_connector_active_topics(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorActiveTopics: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Get the configuration for the specified connector
[apiInstance getConnectorConfigWith:connector
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Get the configuration for the specified connector
                map['String', 'String'] result = apiInstance.getConnectorConfig(connector);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getConnectorConfig: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Get the configuration for the specified connector
    api_response = api_instance.get_connector_config(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorConfig: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        String version = version_example; // String | 

        try {
            array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfigDef");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String pluginName = new String(); // String | 
final String version = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        String version = version_example; // String | 

        try {
            array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getConnectorConfigDef");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *pluginName = pluginName_example; //  (default to null)
String *version = version_example; //  (optional) (default to latest)

// Get the configuration definition for the specified pluginName
[apiInstance getConnectorConfigDefWith:pluginName
    version:version
              completionHandler: ^(array[ConfigKeyInfo] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var pluginName = pluginName_example; // {String} 
var opts = {
  'version': version_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pluginName = pluginName_example;  // String |  (default to null)
            var version = version_example;  // String |  (optional)  (default to latest)

            try {
                // Get the configuration definition for the specified pluginName
                array[ConfigKeyInfo] result = apiInstance.getConnectorConfigDef(pluginName, version);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getConnectorConfigDef: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pluginName = pluginName_example; // String | 
$version = version_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pluginName = pluginName_example; # String | 
my $version = version_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pluginName = pluginName_example # String |  (default to null)
version = version_example # String |  (optional) (default to latest)

try:
    # Get the configuration definition for the specified pluginName
    api_response = api_instance.get_connector_config_def(pluginName, version=version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorConfigDef: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let pluginName = pluginName_example; // String
    let version = version_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getConnectorConfigDef(pluginName, version, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Get the status for the specified connector
[apiInstance getConnectorStatusWith:connector
              completionHandler: ^(ConnectorStateInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Get the status for the specified connector
                ConnectorStateInfo result = apiInstance.getConnectorStatus(connector);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getConnectorStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Get the status for the specified connector
    api_response = api_instance.get_connector_status(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getConnectorStatus: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 

        try {
            apiInstance.getLogger(logger);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLogger");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String logger = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.getLogger(logger);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLogger");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *logger = logger_example; //  (default to null)

// Get the log level for the specified logger
[apiInstance getLoggerWith:logger
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var logger = logger_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var logger = logger_example;  // String |  (default to null)

            try {
                // Get the log level for the specified logger
                apiInstance.getLogger(logger);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getLogger: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->getLogger($logger);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getLogger: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->getLogger(logger => $logger);
};
if ($@) {
    warn "Exception when calling DefaultApi->getLogger: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
logger = logger_example # String |  (default to null)

try:
    # Get the log level for the specified logger
    api_instance.get_logger(logger)
except ApiException as e:
    print("Exception when calling DefaultApi->getLogger: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let logger = logger_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Get the current offsets for the specified connector
[apiInstance getOffsetsWith:connector
              completionHandler: ^(ConnectorOffsets output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Get the current offsets for the specified connector
                ConnectorOffsets result = apiInstance.getOffsets(connector);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getOffsets: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Get the current offsets for the specified connector
    api_response = api_instance.get_offsets(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getOffsets: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// List all tasks and their configurations for the specified connector
[apiInstance getTaskConfigsWith:connector
              completionHandler: ^(array[TaskInfo] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // List all tasks and their configurations for the specified connector
                array[TaskInfo] result = apiInstance.getTaskConfigs(connector);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTaskConfigs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # List all tasks and their configurations for the specified connector
    api_response = api_instance.get_task_configs(connector)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTaskConfigs: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 

        try {
            TaskState result = apiInstance.getTaskStatus(connector, task);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final Integer task = new Integer(); // Integer | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 

        try {
            TaskState result = apiInstance.getTaskStatus(connector, task);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTaskStatus");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
Integer *task = 56; //  (default to null)

// Get the state of the specified task for the specified connector
[apiInstance getTaskStatusWith:connector
    task:task
              completionHandler: ^(TaskState output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var task = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var task = 56;  // Integer |  (default to null)

            try {
                // Get the state of the specified task for the specified connector
                TaskState result = apiInstance.getTaskStatus(connector, task);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTaskStatus: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$task = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $task = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
task = 56 # Integer |  (default to null)

try:
    # Get the state of the specified task for the specified connector
    api_response = api_instance.get_task_status(connector, task)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTaskStatus: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let task = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getTaskStatus(connector, task, &context).wait();

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

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

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

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

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

        try {
            apiInstance.healthCheck();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#healthCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.healthCheck();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#healthCheck");
            e.printStackTrace();
        }
    }
}

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

// Health check endpoint to verify worker readiness and liveness
[apiInstance healthCheckWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

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

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

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

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

            try {
                // Health check endpoint to verify worker readiness and liveness
                apiInstance.healthCheck();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.healthCheck: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->healthCheck();
};
if ($@) {
    warn "Exception when calling DefaultApi->healthCheck: $@\n";
}

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

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

try:
    # Health check endpoint to verify worker readiness and liveness
    api_instance.health_check()
except ApiException as e:
    print("Exception when calling DefaultApi->healthCheck: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Boolean connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean connectorsOnly = new Boolean(); // Boolean | Whether to list only connectors instead of all plugins

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Boolean connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Boolean *connectorsOnly = true; // Whether to list only connectors instead of all plugins (optional) (default to true)

// List all connector plugins installed
[apiInstance listConnectorPluginsWith:connectorsOnly
              completionHandler: ^(array[PluginInfo] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var opts = {
  'connectorsOnly': true // {Boolean} Whether to list only connectors instead of all plugins
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connectorsOnly = true;  // Boolean | Whether to list only connectors instead of all plugins (optional)  (default to true)

            try {
                // List all connector plugins installed
                array[PluginInfo] result = apiInstance.listConnectorPlugins(connectorsOnly);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listConnectorPlugins: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connectorsOnly = true; // Boolean | Whether to list only connectors instead of all plugins

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connectorsOnly = true; # Boolean | Whether to list only connectors instead of all plugins

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connectorsOnly = true # Boolean | Whether to list only connectors instead of all plugins (optional) (default to true)

try:
    # List all connector plugins installed
    api_response = api_instance.list_connector_plugins(connectorsOnly=connectorsOnly)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listConnectorPlugins: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connectorsOnly = true; // Boolean

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

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

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

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

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

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

        try {
            apiInstance.listConnectors();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listConnectors");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.listConnectors();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listConnectors");
            e.printStackTrace();
        }
    }
}

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

// List all active connectors
[apiInstance listConnectorsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

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

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

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

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

            try {
                // List all active connectors
                apiInstance.listConnectors();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->listConnectors();
};
if ($@) {
    warn "Exception when calling DefaultApi->listConnectors: $@\n";
}

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

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

try:
    # List all active connectors
    api_instance.list_connectors()
except ApiException as e:
    print("Exception when calling DefaultApi->listConnectors: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

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

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

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

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

        try {
            apiInstance.listLoggers();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listLoggers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.listLoggers();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listLoggers");
            e.printStackTrace();
        }
    }
}

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

// List the current loggers that have their levels explicitly set and their log levels
[apiInstance listLoggersWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

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

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

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

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

            try {
                // List the current loggers that have their levels explicitly set and their log levels
                apiInstance.listLoggers();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listLoggers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->listLoggers();
};
if ($@) {
    warn "Exception when calling DefaultApi->listLoggers: $@\n";
}

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

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

try:
    # List the current loggers that have their levels explicitly set and their log levels
    api_instance.list_loggers()
except ApiException as e:
    print("Exception when calling DefaultApi->listLoggers: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.patchConnectorConfig(connector, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchConnectorConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final map[String, String] requestBody = new map[String, String](); // map[String, String] | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.patchConnectorConfig(connector, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchConnectorConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
map[String, String] *requestBody = ; //  (optional)

[apiInstance patchConnectorConfigWith:connector
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var opts = {
  'requestBody':  // {map[String, String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var requestBody = new map[String, String](); // map[String, String] |  (optional) 

            try {
                apiInstance.patchConnectorConfig(connector, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchConnectorConfig: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$requestBody = ; // map[String, String] | 

try {
    $api_instance->patchConnectorConfig($connector, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchConnectorConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, String]->new(); # map[String, String] | 

eval {
    $api_instance->patchConnectorConfig(connector => $connector, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchConnectorConfig: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
requestBody =  # map[String, String] |  (optional)

try:
    api_instance.patch_connector_config(connector, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DefaultApi->patchConnectorConfig: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let requestBody = ; // map[String, String]

    let mut context = DefaultApi::Context::default();
    let result = client.patchConnectorConfig(connector, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.pauseConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pauseConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.pauseConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pauseConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Pause the specified connector
[apiInstance pauseConnectorWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Pause the specified connector
                apiInstance.pauseConnector(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.pauseConnector: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->pauseConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pauseConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->pauseConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->pauseConnector: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Pause the specified connector
    api_instance.pause_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->pauseConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.putConnectorConfig(connector, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putConnectorConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final map[String, String] requestBody = new map[String, String](); // map[String, String] | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.putConnectorConfig(connector, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putConnectorConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
map[String, String] *requestBody = ; //  (optional)

// Create or reconfigure the specified connector
[apiInstance putConnectorConfigWith:connector
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var opts = {
  'requestBody':  // {map[String, String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var requestBody = new map[String, String](); // map[String, String] |  (optional) 

            try {
                // Create or reconfigure the specified connector
                apiInstance.putConnectorConfig(connector, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.putConnectorConfig: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$requestBody = ; // map[String, String] | 

try {
    $api_instance->putConnectorConfig($connector, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->putConnectorConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, String]->new(); # map[String, String] | 

eval {
    $api_instance->putConnectorConfig(connector => $connector, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DefaultApi->putConnectorConfig: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
requestBody =  # map[String, String] |  (optional)

try:
    # Create or reconfigure the specified connector
    api_instance.put_connector_config(connector, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DefaultApi->putConnectorConfig: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let requestBody = ; // map[String, String]

    let mut context = DefaultApi::Context::default();
    let result = client.putConnectorConfig(connector, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.resetConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.resetConnectorActiveTopics(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorActiveTopics");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Reset the list of topics actively used by the specified connector
[apiInstance resetConnectorActiveTopicsWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Reset the list of topics actively used by the specified connector
                apiInstance.resetConnectorActiveTopics(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.resetConnectorActiveTopics: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->resetConnectorActiveTopics($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->resetConnectorActiveTopics: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->resetConnectorActiveTopics(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->resetConnectorActiveTopics: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Reset the list of topics actively used by the specified connector
    api_instance.reset_connector_active_topics(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->resetConnectorActiveTopics: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.resetConnectorOffsets(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorOffsets");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.resetConnectorOffsets(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resetConnectorOffsets");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Reset the offsets for the specified connector
[apiInstance resetConnectorOffsetsWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Reset the offsets for the specified connector
                apiInstance.resetConnectorOffsets(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.resetConnectorOffsets: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->resetConnectorOffsets($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->resetConnectorOffsets: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->resetConnectorOffsets(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->resetConnectorOffsets: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Reset the offsets for the specified connector
    api_instance.reset_connector_offsets(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->resetConnectorOffsets: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Boolean includeTasks = true; // Boolean | Whether to also restart tasks
        Boolean onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors

        try {
            apiInstance.restartConnector(connector, includeTasks, onlyFailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final Boolean includeTasks = new Boolean(); // Boolean | Whether to also restart tasks
final Boolean onlyFailed = new Boolean(); // Boolean | Whether to only restart failed tasks/connectors

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Boolean includeTasks = true; // Boolean | Whether to also restart tasks
        Boolean onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors

        try {
            apiInstance.restartConnector(connector, includeTasks, onlyFailed);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
Boolean *includeTasks = true; // Whether to also restart tasks (optional) (default to false)
Boolean *onlyFailed = true; // Whether to only restart failed tasks/connectors (optional) (default to false)

// Restart the specified connector
[apiInstance restartConnectorWith:connector
    includeTasks:includeTasks
    onlyFailed:onlyFailed
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var opts = {
  'includeTasks': true, // {Boolean} Whether to also restart tasks
  'onlyFailed': true // {Boolean} Whether to only restart failed tasks/connectors
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var includeTasks = true;  // Boolean | Whether to also restart tasks (optional)  (default to false)
            var onlyFailed = true;  // Boolean | Whether to only restart failed tasks/connectors (optional)  (default to false)

            try {
                // Restart the specified connector
                apiInstance.restartConnector(connector, includeTasks, onlyFailed);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.restartConnector: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$includeTasks = true; // Boolean | Whether to also restart tasks
$onlyFailed = true; // Boolean | Whether to only restart failed tasks/connectors

try {
    $api_instance->restartConnector($connector, $includeTasks, $onlyFailed);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->restartConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $includeTasks = true; # Boolean | Whether to also restart tasks
my $onlyFailed = true; # Boolean | Whether to only restart failed tasks/connectors

eval {
    $api_instance->restartConnector(connector => $connector, includeTasks => $includeTasks, onlyFailed => $onlyFailed);
};
if ($@) {
    warn "Exception when calling DefaultApi->restartConnector: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
includeTasks = true # Boolean | Whether to also restart tasks (optional) (default to false)
onlyFailed = true # Boolean | Whether to only restart failed tasks/connectors (optional) (default to false)

try:
    # Restart the specified connector
    api_instance.restart_connector(connector, includeTasks=includeTasks, onlyFailed=onlyFailed)
except ApiException as e:
    print("Exception when calling DefaultApi->restartConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let includeTasks = true; // Boolean
    let onlyFailed = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.restartConnector(connector, includeTasks, onlyFailed, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 

        try {
            apiInstance.restartTask(connector, task);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartTask");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 
final Integer task = new Integer(); // Integer | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 
        Integer task = 56; // Integer | 

        try {
            apiInstance.restartTask(connector, task);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#restartTask");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)
Integer *task = 56; //  (default to null)

// Restart the specified task for the specified connector
[apiInstance restartTaskWith:connector
    task:task
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 
var task = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)
            var task = 56;  // Integer |  (default to null)

            try {
                // Restart the specified task for the specified connector
                apiInstance.restartTask(connector, task);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.restartTask: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$connector = connector_example; // String | 
$task = 56; // Integer | 

try {
    $api_instance->restartTask($connector, $task);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->restartTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $connector = connector_example; # String | 
my $task = 56; # Integer | 

eval {
    $api_instance->restartTask(connector => $connector, task => $task);
};
if ($@) {
    warn "Exception when calling DefaultApi->restartTask: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)
task = 56 # Integer |  (default to null)

try:
    # Restart the specified task for the specified connector
    api_instance.restart_task(connector, task)
except ApiException as e:
    print("Exception when calling DefaultApi->restartTask: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String
    let task = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.restartTask(connector, task, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.resumeConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resumeConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.resumeConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#resumeConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Resume the specified connector
[apiInstance resumeConnectorWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Resume the specified connector
                apiInstance.resumeConnector(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.resumeConnector: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->resumeConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->resumeConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->resumeConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->resumeConnector: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Resume the specified connector
    api_instance.resume_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->resumeConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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

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

// Get details about this Connect worker and the ID of the Kafka cluster it is connected to
[apiInstance serverInfoWithCompletionHandler: 
              ^(ServerInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

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

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

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

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

            try {
                // Get details about this Connect worker and the ID of the Kafka cluster it is connected to
                ServerInfo result = apiInstance.serverInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.serverInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get details about this Connect worker and the ID of the Kafka cluster it is connected to
    api_response = api_instance.server_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->serverInfo: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        String scope = scope_example; // String | The scope for the logging modification (single-worker, cluster-wide, etc.)
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.setLevel(logger, scope, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setLevel");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String logger = new String(); // String | 
final String scope = new String(); // String | The scope for the logging modification (single-worker, cluster-wide, etc.)
final map[String, String] requestBody = new map[String, String](); // map[String, String] | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String logger = logger_example; // String | 
        String scope = scope_example; // String | The scope for the logging modification (single-worker, cluster-wide, etc.)
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            apiInstance.setLevel(logger, scope, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setLevel");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *logger = logger_example; //  (default to null)
String *scope = scope_example; // The scope for the logging modification (single-worker, cluster-wide, etc.) (optional) (default to worker)
map[String, String] *requestBody = ; //  (optional)

// Set the log level for the specified logger
[apiInstance setLevelWith:logger
    scope:scope
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var logger = logger_example; // {String} 
var opts = {
  'scope': scope_example, // {String} The scope for the logging modification (single-worker, cluster-wide, etc.)
  'requestBody':  // {map[String, String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var logger = logger_example;  // String |  (default to null)
            var scope = scope_example;  // String | The scope for the logging modification (single-worker, cluster-wide, etc.) (optional)  (default to worker)
            var requestBody = new map[String, String](); // map[String, String] |  (optional) 

            try {
                // Set the log level for the specified logger
                apiInstance.setLevel(logger, scope, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.setLevel: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$logger = logger_example; // String | 
$scope = scope_example; // String | The scope for the logging modification (single-worker, cluster-wide, etc.)
$requestBody = ; // map[String, String] | 

try {
    $api_instance->setLevel($logger, $scope, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->setLevel: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $logger = logger_example; # String | 
my $scope = scope_example; # String | The scope for the logging modification (single-worker, cluster-wide, etc.)
my $requestBody = WWW::OPenAPIClient::Object::map[String, String]->new(); # map[String, String] | 

eval {
    $api_instance->setLevel(logger => $logger, scope => $scope, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DefaultApi->setLevel: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
logger = logger_example # String |  (default to null)
scope = scope_example # String | The scope for the logging modification (single-worker, cluster-wide, etc.) (optional) (default to worker)
requestBody =  # map[String, String] |  (optional)

try:
    # Set the log level for the specified logger
    api_instance.set_level(logger, scope=scope, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DefaultApi->setLevel: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let logger = logger_example; // String
    let scope = scope_example; // String
    let requestBody = ; // map[String, String]

    let mut context = DefaultApi::Context::default();
    let result = client.setLevel(logger, scope, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String connector = connector_example; // String | 

        try {
            apiInstance.stopConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#stopConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String connector = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.stopConnector(connector);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#stopConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *connector = connector_example; //  (default to null)

// Stop the specified connector
[apiInstance stopConnectorWith:connector
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var connector = connector_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var connector = connector_example;  // String |  (default to null)

            try {
                // Stop the specified connector
                apiInstance.stopConnector(connector);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.stopConnector: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->stopConnector($connector);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->stopConnector: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->stopConnector(connector => $connector);
};
if ($@) {
    warn "Exception when calling DefaultApi->stopConnector: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
connector = connector_example # String |  (default to null)

try:
    # Stop the specified connector
    api_instance.stop_connector(connector)
except ApiException as e:
    print("Exception when calling DefaultApi->stopConnector: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let connector = connector_example; // String

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            ConfigInfos result = apiInstance.validateConfigs(pluginName, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateConfigs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String pluginName = new String(); // String | 
final map[String, String] requestBody = new map[String, String](); // map[String, String] | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String pluginName = pluginName_example; // String | 
        map[String, String] requestBody = ; // map[String, String] | 

        try {
            ConfigInfos result = apiInstance.validateConfigs(pluginName, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateConfigs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *pluginName = pluginName_example; //  (default to null)
map[String, String] *requestBody = ; //  (optional)

// Validate the provided configuration against the configuration definition for the specified pluginName
[apiInstance validateConfigsWith:pluginName
    requestBody:requestBody
              completionHandler: ^(ConfigInfos output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KafkaConnectRestApi = require('kafka_connect_rest_api');

// Create an instance of the API class
var api = new KafkaConnectRestApi.DefaultApi()
var pluginName = pluginName_example; // {String} 
var opts = {
  'requestBody':  // {map[String, String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pluginName = pluginName_example;  // String |  (default to null)
            var requestBody = new map[String, String](); // map[String, String] |  (optional) 

            try {
                // Validate the provided configuration against the configuration definition for the specified pluginName
                ConfigInfos result = apiInstance.validateConfigs(pluginName, requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.validateConfigs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pluginName = pluginName_example; // String | 
$requestBody = ; // map[String, String] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pluginName = pluginName_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, String]->new(); # map[String, String] | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pluginName = pluginName_example # String |  (default to null)
requestBody =  # map[String, String] |  (optional)

try:
    # Validate the provided configuration against the configuration definition for the specified pluginName
    api_response = api_instance.validate_configs(pluginName, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->validateConfigs: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let pluginName = pluginName_example; // String
    let requestBody = ; // map[String, String]

    let mut context = DefaultApi::Context::default();
    let result = client.validateConfigs(pluginName, requestBody, &context).wait();

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