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

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

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

        // Create an instance of the API class
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 
        ApiKeySyncDto apiKeySyncDto = ; // ApiKeySyncDto | 

        try {
            ApiKeyDto result = apiInstance.createApiKey(projectId, apiKeySyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | 
final ApiKeySyncDto apiKeySyncDto = new ApiKeySyncDto(); // ApiKeySyncDto | 

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

import org.openapitools.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {
    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 
        ApiKeySyncDto apiKeySyncDto = ; // ApiKeySyncDto | 

        try {
            ApiKeyDto result = apiInstance.createApiKey(projectId, apiKeySyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
APIKeyOperationsApi *apiInstance = [[APIKeyOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)
ApiKeySyncDto *apiKeySyncDto = ; // 

// Creates a new api key in the specified project.
[apiInstance createApiKeyWith:projectId
    apiKeySyncDto:apiKeySyncDto
              completionHandler: ^(ApiKeyDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.APIKeyOperationsApi()
var projectId = projectId_example; // {String} 
var apiKeySyncDto = ; // {ApiKeySyncDto} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new APIKeyOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)
            var apiKeySyncDto = new ApiKeySyncDto(); // ApiKeySyncDto | 

            try {
                // Creates a new api key in the specified project.
                ApiKeyDto result = apiInstance.createApiKey(projectId, apiKeySyncDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling APIKeyOperationsApi.createApiKey: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\APIKeyOperationsApi();
$projectId = projectId_example; // String | 
$apiKeySyncDto = ; // ApiKeySyncDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::APIKeyOperationsApi->new();
my $projectId = projectId_example; # String | 
my $apiKeySyncDto = WWW::OPenAPIClient::Object::ApiKeySyncDto->new(); # ApiKeySyncDto | 

eval {
    my $result = $api_instance->createApiKey(projectId => $projectId, apiKeySyncDto => $apiKeySyncDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->createApiKey: $@\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.APIKeyOperationsApi()
projectId = projectId_example # String |  (default to null)
apiKeySyncDto =  # ApiKeySyncDto | 

try:
    # Creates a new api key in the specified project.
    api_response = api_instance.create_api_key(projectId, apiKeySyncDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIKeyOperationsApi->createApiKey: %s\n" % e)

extern crate APIKeyOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String
    let apiKeySyncDto = ; // ApiKeySyncDto

    let mut context = APIKeyOperationsApi::Context::default();
    let result = client.createApiKey(projectId, apiKeySyncDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 

        try {
            apiInstance.deleteApiKeyById(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 
final String projectId = new String(); // String | 

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

import org.openapitools.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {
    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 

        try {
            apiInstance.deleteApiKeyById(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
APIKeyOperationsApi *apiInstance = [[APIKeyOperationsApi alloc] init];
Integer *id = 56; //  (default to null)
String *projectId = projectId_example; //  (default to null)

// Deletes an api key from the specified project.
[apiInstance deleteApiKeyByIdWith:id
    projectId:projectId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.APIKeyOperationsApi()
var id = 56; // {Integer} 
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Deletes an api key from the specified project.
                apiInstance.deleteApiKeyById(id, projectId);
            } catch (Exception e) {
                Debug.Print("Exception when calling APIKeyOperationsApi.deleteApiKeyById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\APIKeyOperationsApi();
$id = 56; // Integer | 
$projectId = projectId_example; // String | 

try {
    $api_instance->deleteApiKeyById($id, $projectId);
} catch (Exception $e) {
    echo 'Exception when calling APIKeyOperationsApi->deleteApiKeyById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval {
    $api_instance->deleteApiKeyById(id => $id, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->deleteApiKeyById: $@\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.APIKeyOperationsApi()
id = 56 # Integer |  (default to null)
projectId = projectId_example # String |  (default to null)

try:
    # Deletes an api key from the specified project.
    api_instance.delete_api_key_by_id(id, projectId)
except ApiException as e:
    print("Exception when calling APIKeyOperationsApi->deleteApiKeyById: %s\n" % e)

extern crate APIKeyOperationsApi;

pub fn main() {
    let id = 56; // Integer
    let projectId = projectId_example; // String

    let mut context = APIKeyOperationsApi::Context::default();
    let result = client.deleteApiKeyById(id, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getAllApiKeysInProject");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {
    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getAllApiKeysInProject");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
APIKeyOperationsApi *apiInstance = [[APIKeyOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)

// Retrieves all api keys in the specified project.
[apiInstance getAllApiKeysInProjectWith:projectId
              completionHandler: ^(array[ApiKeyDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.APIKeyOperationsApi()
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new APIKeyOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Retrieves all api keys in the specified project.
                array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling APIKeyOperationsApi.getAllApiKeysInProject: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\APIKeyOperationsApi();
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::APIKeyOperationsApi->new();
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->getAllApiKeysInProject(projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->getAllApiKeysInProject: $@\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.APIKeyOperationsApi()
projectId = projectId_example # String |  (default to null)

try:
    # Retrieves all api keys in the specified project.
    api_response = api_instance.get_all_api_keys_in_project(projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIKeyOperationsApi->getAllApiKeysInProject: %s\n" % e)

extern crate APIKeyOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String

    let mut context = APIKeyOperationsApi::Context::default();
    let result = client.getAllApiKeysInProject(projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 

        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 
final String projectId = new String(); // String | 

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

import org.openapitools.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {
    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 

        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
APIKeyOperationsApi *apiInstance = [[APIKeyOperationsApi alloc] init];
Integer *id = 56; //  (default to null)
String *projectId = projectId_example; //  (default to null)

// Retrieves an api key from the specified project by its id.
[apiInstance getApiKeyByIdWith:id
    projectId:projectId
              completionHandler: ^(ApiKeyDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.APIKeyOperationsApi()
var id = 56; // {Integer} 
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Retrieves an api key from the specified project by its id.
                ApiKeyDto result = apiInstance.getApiKeyById(id, projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling APIKeyOperationsApi.getApiKeyById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\APIKeyOperationsApi();
$id = 56; // Integer | 
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->getApiKeyById(id => $id, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->getApiKeyById: $@\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.APIKeyOperationsApi()
id = 56 # Integer |  (default to null)
projectId = projectId_example # String |  (default to null)

try:
    # Retrieves an api key from the specified project by its id.
    api_response = api_instance.get_api_key_by_id(id, projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIKeyOperationsApi->getApiKeyById: %s\n" % e)

extern crate APIKeyOperationsApi;

pub fn main() {
    let id = 56; // Integer
    let projectId = projectId_example; // String

    let mut context = APIKeyOperationsApi::Context::default();
    let result = client.getApiKeyById(id, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        GenerateKeytabRequest generateKeytabRequest = ; // GenerateKeytabRequest | 

        try {
            apiInstance.generateKeytab1(userId, generateKeytabRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | 
final GenerateKeytabRequest generateKeytabRequest = new GenerateKeytabRequest(); // GenerateKeytabRequest | 

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

import org.openapitools.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {
    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        GenerateKeytabRequest generateKeytabRequest = ; // GenerateKeytabRequest | 

        try {
            apiInstance.generateKeytab1(userId, generateKeytabRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminOperationsApi *apiInstance = [[AdminOperationsApi alloc] init];
String *userId = userId_example; //  (default to null)
GenerateKeytabRequest *generateKeytabRequest = ; // 

// Generates a keytab for the user with the given credentials.
[apiInstance generateKeytab1With:userId
    generateKeytabRequest:generateKeytabRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminOperationsApi()
var userId = userId_example; // {String} 
var generateKeytabRequest = ; // {GenerateKeytabRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String |  (default to null)
            var generateKeytabRequest = new GenerateKeytabRequest(); // GenerateKeytabRequest | 

            try {
                // Generates a keytab for the user with the given credentials.
                apiInstance.generateKeytab1(userId, generateKeytabRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminOperationsApi.generateKeytab1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminOperationsApi();
$userId = userId_example; // String | 
$generateKeytabRequest = ; // GenerateKeytabRequest | 

try {
    $api_instance->generateKeytab1($userId, $generateKeytabRequest);
} catch (Exception $e) {
    echo 'Exception when calling AdminOperationsApi->generateKeytab1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $generateKeytabRequest = WWW::OPenAPIClient::Object::GenerateKeytabRequest->new(); # GenerateKeytabRequest | 

eval {
    $api_instance->generateKeytab1(userId => $userId, generateKeytabRequest => $generateKeytabRequest);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->generateKeytab1: $@\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.AdminOperationsApi()
userId = userId_example # String |  (default to null)
generateKeytabRequest =  # GenerateKeytabRequest | 

try:
    # Generates a keytab for the user with the given credentials.
    api_instance.generate_keytab1(userId, generateKeytabRequest)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->generateKeytab1: %s\n" % e)

extern crate AdminOperationsApi;

pub fn main() {
    let userId = userId_example; // String
    let generateKeytabRequest = ; // GenerateKeytabRequest

    let mut context = AdminOperationsApi::Context::default();
    let result = client.generateKeytab1(userId, generateKeytabRequest, &context).wait();

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

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

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

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

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

        try {
            CountersResponse result = apiInstance.getDiagnostics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#getDiagnostics");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminOperationsApi;

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

        try {
            CountersResponse result = apiInstance.getDiagnostics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#getDiagnostics");
            e.printStackTrace();
        }
    }
}

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

[apiInstance getDiagnosticsWithCompletionHandler: 
              ^(CountersResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                CountersResponse result = apiInstance.getDiagnostics();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminOperationsApi.getDiagnostics: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.get_diagnostics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->getDiagnostics: %s\n" % e)

extern crate AdminOperationsApi;

pub fn main() {

    let mut context = AdminOperationsApi::Context::default();
    let result = client.getDiagnostics(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        UpdatePasswordRequest updatePasswordRequest = ; // UpdatePasswordRequest | 

        try {
            apiInstance.updateUserPassword1(userId, updatePasswordRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | 
final UpdatePasswordRequest updatePasswordRequest = new UpdatePasswordRequest(); // UpdatePasswordRequest | 

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

import org.openapitools.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {
    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        UpdatePasswordRequest updatePasswordRequest = ; // UpdatePasswordRequest | 

        try {
            apiInstance.updateUserPassword1(userId, updatePasswordRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminOperationsApi *apiInstance = [[AdminOperationsApi alloc] init];
String *userId = userId_example; //  (default to null)
UpdatePasswordRequest *updatePasswordRequest = ; // 

// Updates the password for the user.
[apiInstance updateUserPassword1With:userId
    updatePasswordRequest:updatePasswordRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminOperationsApi()
var userId = userId_example; // {String} 
var updatePasswordRequest = ; // {UpdatePasswordRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String |  (default to null)
            var updatePasswordRequest = new UpdatePasswordRequest(); // UpdatePasswordRequest | 

            try {
                // Updates the password for the user.
                apiInstance.updateUserPassword1(userId, updatePasswordRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminOperationsApi.updateUserPassword1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminOperationsApi();
$userId = userId_example; // String | 
$updatePasswordRequest = ; // UpdatePasswordRequest | 

try {
    $api_instance->updateUserPassword1($userId, $updatePasswordRequest);
} catch (Exception $e) {
    echo 'Exception when calling AdminOperationsApi->updateUserPassword1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $updatePasswordRequest = WWW::OPenAPIClient::Object::UpdatePasswordRequest->new(); # UpdatePasswordRequest | 

eval {
    $api_instance->updateUserPassword1(userId => $userId, updatePasswordRequest => $updatePasswordRequest);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->updateUserPassword1: $@\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.AdminOperationsApi()
userId = userId_example # String |  (default to null)
updatePasswordRequest =  # UpdatePasswordRequest | 

try:
    # Updates the password for the user.
    api_instance.update_user_password1(userId, updatePasswordRequest)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->updateUserPassword1: %s\n" % e)

extern crate AdminOperationsApi;

pub fn main() {
    let userId = userId_example; // String
    let updatePasswordRequest = ; // UpdatePasswordRequest

    let mut context = AdminOperationsApi::Context::default();
    let result = client.updateUserPassword1(userId, updatePasswordRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        String principal = principal_example; // String | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            apiInstance.uploadKeytab1(userId, principal, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | 
final String principal = new String(); // String | 
final File file = new File(); // File | 

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

import org.openapitools.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {
    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        String principal = principal_example; // String | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            apiInstance.uploadKeytab1(userId, principal, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminOperationsApi *apiInstance = [[AdminOperationsApi alloc] init];
String *userId = userId_example; //  (default to null)
String *principal = principal_example; //  (default to null)
File *file = BINARY_DATA_HERE; //  (default to null)

// Uploads a keytab file for the user with the given credentials.
[apiInstance uploadKeytab1With:userId
    principal:principal
    file:file
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminOperationsApi()
var userId = userId_example; // {String} 
var principal = principal_example; // {String} 
var file = BINARY_DATA_HERE; // {File} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.uploadKeytab1(userId, principal, file, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String |  (default to null)
            var principal = principal_example;  // String |  (default to null)
            var file = BINARY_DATA_HERE;  // File |  (default to null)

            try {
                // Uploads a keytab file for the user with the given credentials.
                apiInstance.uploadKeytab1(userId, principal, file);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminOperationsApi.uploadKeytab1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminOperationsApi();
$userId = userId_example; // String | 
$principal = principal_example; // String | 
$file = BINARY_DATA_HERE; // File | 

try {
    $api_instance->uploadKeytab1($userId, $principal, $file);
} catch (Exception $e) {
    echo 'Exception when calling AdminOperationsApi->uploadKeytab1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $principal = principal_example; # String | 
my $file = BINARY_DATA_HERE; # File | 

eval {
    $api_instance->uploadKeytab1(userId => $userId, principal => $principal, file => $file);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->uploadKeytab1: $@\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.AdminOperationsApi()
userId = userId_example # String |  (default to null)
principal = principal_example # String |  (default to null)
file = BINARY_DATA_HERE # File |  (default to null)

try:
    # Uploads a keytab file for the user with the given credentials.
    api_instance.upload_keytab1(userId, principal, file)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->uploadKeytab1: %s\n" % e)

extern crate AdminOperationsApi;

pub fn main() {
    let userId = userId_example; // String
    let principal = principal_example; // String
    let file = BINARY_DATA_HERE; // File

    let mut context = AdminOperationsApi::Context::default();
    let result = client.uploadKeytab1(userId, principal, file, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            apiInstance.deleteArtifactV2(name, scope, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifactV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | 
final String scope = new String(); // String | 
final String projectId = new String(); // String | If scope is PROJECT, projectId has to be provided

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

import org.openapitools.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {
    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            apiInstance.deleteArtifactV2(name, scope, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifactV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ArtifactOperationsApi *apiInstance = [[ArtifactOperationsApi alloc] init];
String *name = name_example; //  (default to null)
String *scope = scope_example; //  (optional) (default to USER)
String *projectId = projectId_example; // If scope is PROJECT, projectId has to be provided (optional) (default to null)

// Delete an artifact that is available to the user.
[apiInstance deleteArtifactV2With:name
    scope:scope
    projectId:projectId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ArtifactOperationsApi()
var name = name_example; // {String} 
var opts = {
  'scope': scope_example, // {String} 
  'projectId': projectId_example // {String} If scope is PROJECT, projectId has to be provided
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ArtifactOperationsApi();
            var name = name_example;  // String |  (default to null)
            var scope = scope_example;  // String |  (optional)  (default to USER)
            var projectId = projectId_example;  // String | If scope is PROJECT, projectId has to be provided (optional)  (default to null)

            try {
                // Delete an artifact that is available to the user.
                apiInstance.deleteArtifactV2(name, scope, projectId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ArtifactOperationsApi.deleteArtifactV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ArtifactOperationsApi();
$name = name_example; // String | 
$scope = scope_example; // String | 
$projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

try {
    $api_instance->deleteArtifactV2($name, $scope, $projectId);
} catch (Exception $e) {
    echo 'Exception when calling ArtifactOperationsApi->deleteArtifactV2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ArtifactOperationsApi->new();
my $name = name_example; # String | 
my $scope = scope_example; # String | 
my $projectId = projectId_example; # String | If scope is PROJECT, projectId has to be provided

eval {
    $api_instance->deleteArtifactV2(name => $name, scope => $scope, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->deleteArtifactV2: $@\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.ArtifactOperationsApi()
name = name_example # String |  (default to null)
scope = scope_example # String |  (optional) (default to USER)
projectId = projectId_example # String | If scope is PROJECT, projectId has to be provided (optional) (default to null)

try:
    # Delete an artifact that is available to the user.
    api_instance.delete_artifact_v2(name, scope=scope, projectId=projectId)
except ApiException as e:
    print("Exception when calling ArtifactOperationsApi->deleteArtifactV2: %s\n" % e)

extern crate ArtifactOperationsApi;

pub fn main() {
    let name = name_example; // String
    let scope = scope_example; // String
    let projectId = projectId_example; // String

    let mut context = ArtifactOperationsApi::Context::default();
    let result = client.deleteArtifactV2(name, scope, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifactV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | 
final String scope = new String(); // String | 
final String projectId = new String(); // String | If scope is PROJECT, projectId has to be provided

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

import org.openapitools.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {
    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifactV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ArtifactOperationsApi *apiInstance = [[ArtifactOperationsApi alloc] init];
String *name = name_example; //  (optional) (default to null)
String *scope = scope_example; //  (optional) (default to USER)
String *projectId = projectId_example; // If scope is PROJECT, projectId has to be provided (optional) (default to null)

// Lists artifacts available to the user. They can be filtered by scope or name.
[apiInstance getArtifactV2With:name
    scope:scope
    projectId:projectId
              completionHandler: ^(array[ArtifactDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ArtifactOperationsApi()
var opts = {
  'name': name_example, // {String} 
  'scope': scope_example, // {String} 
  'projectId': projectId_example // {String} If scope is PROJECT, projectId has to be provided
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ArtifactOperationsApi();
            var name = name_example;  // String |  (optional)  (default to null)
            var scope = scope_example;  // String |  (optional)  (default to USER)
            var projectId = projectId_example;  // String | If scope is PROJECT, projectId has to be provided (optional)  (default to null)

            try {
                // Lists artifacts available to the user. They can be filtered by scope or name.
                array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ArtifactOperationsApi.getArtifactV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ArtifactOperationsApi();
$name = name_example; // String | 
$scope = scope_example; // String | 
$projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ArtifactOperationsApi->new();
my $name = name_example; # String | 
my $scope = scope_example; # String | 
my $projectId = projectId_example; # String | If scope is PROJECT, projectId has to be provided

eval {
    my $result = $api_instance->getArtifactV2(name => $name, scope => $scope, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->getArtifactV2: $@\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.ArtifactOperationsApi()
name = name_example # String |  (optional) (default to null)
scope = scope_example # String |  (optional) (default to USER)
projectId = projectId_example # String | If scope is PROJECT, projectId has to be provided (optional) (default to null)

try:
    # Lists artifacts available to the user. They can be filtered by scope or name.
    api_response = api_instance.get_artifact_v2(name=name, scope=scope, projectId=projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ArtifactOperationsApi->getArtifactV2: %s\n" % e)

extern crate ArtifactOperationsApi;

pub fn main() {
    let name = name_example; // String
    let scope = scope_example; // String
    let projectId = projectId_example; // String

    let mut context = ArtifactOperationsApi::Context::default();
    let result = client.getArtifactV2(name, scope, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        File file = BINARY_DATA_HERE; // File | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(file, name, scope, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifactV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final File file = new File(); // File | 
final String name = new String(); // String | 
final String scope = new String(); // String | 
final String projectId = new String(); // String | If scope is PROJECT, projectId has to be provided

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

import org.openapitools.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {
    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        File file = BINARY_DATA_HERE; // File | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(file, name, scope, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifactV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ArtifactOperationsApi *apiInstance = [[ArtifactOperationsApi alloc] init];
File *file = BINARY_DATA_HERE; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *scope = scope_example; //  (optional) (default to USER)
String *projectId = projectId_example; // If scope is PROJECT, projectId has to be provided (optional) (default to null)

// Upload an artifact file.
[apiInstance uploadArtifactV2With:file
    name:name
    scope:scope
    projectId:projectId
              completionHandler: ^(ArtifactDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ArtifactOperationsApi()
var file = BINARY_DATA_HERE; // {File} 
var opts = {
  'name': name_example, // {String} 
  'scope': scope_example, // {String} 
  'projectId': projectId_example // {String} If scope is PROJECT, projectId has to be provided
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ArtifactOperationsApi();
            var file = BINARY_DATA_HERE;  // File |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var scope = scope_example;  // String |  (optional)  (default to USER)
            var projectId = projectId_example;  // String | If scope is PROJECT, projectId has to be provided (optional)  (default to null)

            try {
                // Upload an artifact file.
                ArtifactDto result = apiInstance.uploadArtifactV2(file, name, scope, projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ArtifactOperationsApi.uploadArtifactV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ArtifactOperationsApi();
$file = BINARY_DATA_HERE; // File | 
$name = name_example; // String | 
$scope = scope_example; // String | 
$projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided

try {
    $result = $api_instance->uploadArtifactV2($file, $name, $scope, $projectId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ArtifactOperationsApi->uploadArtifactV2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ArtifactOperationsApi->new();
my $file = BINARY_DATA_HERE; # File | 
my $name = name_example; # String | 
my $scope = scope_example; # String | 
my $projectId = projectId_example; # String | If scope is PROJECT, projectId has to be provided

eval {
    my $result = $api_instance->uploadArtifactV2(file => $file, name => $name, scope => $scope, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->uploadArtifactV2: $@\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.ArtifactOperationsApi()
file = BINARY_DATA_HERE # File |  (default to null)
name = name_example # String |  (optional) (default to null)
scope = scope_example # String |  (optional) (default to USER)
projectId = projectId_example # String | If scope is PROJECT, projectId has to be provided (optional) (default to null)

try:
    # Upload an artifact file.
    api_response = api_instance.upload_artifact_v2(file, name=name, scope=scope, projectId=projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ArtifactOperationsApi->uploadArtifactV2: %s\n" % e)

extern crate ArtifactOperationsApi;

pub fn main() {
    let file = BINARY_DATA_HERE; // File
    let name = name_example; // String
    let scope = scope_example; // String
    let projectId = projectId_example; // String

    let mut context = ArtifactOperationsApi::Context::default();
    let result = client.uploadArtifactV2(file, name, scope, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        ConnectorDto data = ; // ConnectorDto | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            ConnectorDto result = apiInstance.createConnector(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ConnectorDto data = new ConnectorDto(); // ConnectorDto | 
final File file = new File(); // File | 

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        ConnectorDto data = ; // ConnectorDto | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            ConnectorDto result = apiInstance.createConnector(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
ConnectorDto *data = ; //  (default to null)
File *file = BINARY_DATA_HERE; //  (optional) (default to null)

// Creates a Connector.
[apiInstance createConnectorWith:data
    file:file
              completionHandler: ^(ConnectorDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var data = ; // {ConnectorDto} 
var opts = {
  'file': BINARY_DATA_HERE // {File} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createConnector(data, 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 ConnectorOperationsApi();
            var data = new ConnectorDto(); // ConnectorDto |  (default to null)
            var file = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                // Creates a Connector.
                ConnectorDto result = apiInstance.createConnector(data, file);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.createConnector: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$data = ; // ConnectorDto | 
$file = BINARY_DATA_HERE; // File | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $data = ; # ConnectorDto | 
my $file = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->createConnector(data => $data, file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->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.ConnectorOperationsApi()
data =  # ConnectorDto |  (default to null)
file = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    # Creates a Connector.
    api_response = api_instance.create_connector(data, file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->createConnector: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let data = ; // ConnectorDto
    let file = BINARY_DATA_HERE; // File

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.createConnector(data, file, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 

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

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
Integer *id = 56; //  (default to null)

// Deletes a Connector by ID.
[apiInstance deleteConnectorByIdWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var id = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer |  (default to null)

            try {
                // Deletes a Connector by ID.
                apiInstance.deleteConnectorById(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.deleteConnectorById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$id = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $id = 56; # Integer | 

eval {
    $api_instance->deleteConnectorById(id => $id);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->deleteConnectorById: $@\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.ConnectorOperationsApi()
id = 56 # Integer |  (default to null)

try:
    # Deletes a Connector by ID.
    api_instance.delete_connector_by_id(id)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->deleteConnectorById: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let id = 56; // Integer

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.deleteConnectorById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

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

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
String *type = type_example; //  (default to null)

// Deletes a Connector by type.
[apiInstance deleteConnectorByTypeWith:type
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Deletes a Connector by type.
                apiInstance.deleteConnectorByType(type);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.deleteConnectorByType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $type = type_example; # String | 

eval {
    $api_instance->deleteConnectorByType(type => $type);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->deleteConnectorByType: $@\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.ConnectorOperationsApi()
type = type_example # String |  (default to null)

try:
    # Deletes a Connector by type.
    api_instance.delete_connector_by_type(type)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->deleteConnectorByType: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let type = type_example; // String

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.deleteConnectorByType(type, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 

        try {
            ConnectorDto result = apiInstance.getConnectorById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 

        try {
            ConnectorDto result = apiInstance.getConnectorById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
Integer *id = 56; //  (default to null)

// Retrieves a Connector by ID.
[apiInstance getConnectorByIdWith:id
              completionHandler: ^(ConnectorDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var id = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer |  (default to null)

            try {
                // Retrieves a Connector by ID.
                ConnectorDto result = apiInstance.getConnectorById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.getConnectorById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$id = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $id = 56; # Integer | 

eval {
    my $result = $api_instance->getConnectorById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorById: $@\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.ConnectorOperationsApi()
id = 56 # Integer |  (default to null)

try:
    # Retrieves a Connector by ID.
    api_response = api_instance.get_connector_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorById: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let id = 56; // Integer

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.getConnectorById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

        try {
            ConnectorDto result = apiInstance.getConnectorByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorByType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

        try {
            ConnectorDto result = apiInstance.getConnectorByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorByType");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
String *type = type_example; //  (default to null)

// Retrieves a Connector by type.
[apiInstance getConnectorByTypeWith:type
              completionHandler: ^(ConnectorDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Retrieves a Connector by type.
                ConnectorDto result = apiInstance.getConnectorByType(type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.getConnectorByType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $type = type_example; # String | 

eval {
    my $result = $api_instance->getConnectorByType(type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorByType: $@\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.ConnectorOperationsApi()
type = type_example # String |  (default to null)

try:
    # Retrieves a Connector by type.
    api_response = api_instance.get_connector_by_type(type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorByType: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let type = type_example; // String

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.getConnectorByType(type, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {
    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 

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

// Create an instance of the API class
ConnectorOperationsApi *apiInstance = [[ConnectorOperationsApi alloc] init];
String *type = type_example; //  (default to null)

// Retrieves a Connector JAR file. Connector type must be specified.
[apiInstance getConnectorJarFileWith:type
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ConnectorOperationsApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Retrieves a Connector JAR file. Connector type must be specified.
                apiInstance.getConnectorJarFile(type);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.getConnectorJarFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectorOperationsApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectorOperationsApi->new();
my $type = type_example; # String | 

eval {
    $api_instance->getConnectorJarFile(type => $type);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorJarFile: $@\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.ConnectorOperationsApi()
type = type_example # String |  (default to null)

try:
    # Retrieves a Connector JAR file. Connector type must be specified.
    api_instance.get_connector_jar_file(type)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorJarFile: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {
    let type = type_example; // String

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.getConnectorJarFile(type, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConnectorOperationsApi;

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

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

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

// Retrieves all connectors.
[apiInstance getConnectorsWithCompletionHandler: 
              ^(array[ConnectorDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Retrieves all connectors.
                array[ConnectorDto] result = apiInstance.getConnectors();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectorOperationsApi.getConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Retrieves all connectors.
    api_response = api_instance.get_connectors()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectors: %s\n" % e)

extern crate ConnectorOperationsApi;

pub fn main() {

    let mut context = ConnectorOperationsApi::Context::default();
    let result = client.getConnectors(&context).wait();

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

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

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

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

        // Create an instance of the API class
        DDLTemplatesApi apiInstance = new DDLTemplatesApi();
        GenerateCreateTableRequest generateCreateTableRequest = ; // GenerateCreateTableRequest | 

        try {
            GenerateCreateTableResponse result = apiInstance.createTable(generateCreateTableRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DDLTemplatesApi#createTable");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GenerateCreateTableRequest generateCreateTableRequest = new GenerateCreateTableRequest(); // GenerateCreateTableRequest | 

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

import org.openapitools.client.api.DDLTemplatesApi;

public class DDLTemplatesApiExample {
    public static void main(String[] args) {
        DDLTemplatesApi apiInstance = new DDLTemplatesApi();
        GenerateCreateTableRequest generateCreateTableRequest = ; // GenerateCreateTableRequest | 

        try {
            GenerateCreateTableResponse result = apiInstance.createTable(generateCreateTableRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DDLTemplatesApi#createTable");
            e.printStackTrace();
        }
    }
}

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

[apiInstance createTableWith:generateCreateTableRequest
              completionHandler: ^(GenerateCreateTableResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DDLTemplatesApi()
var generateCreateTableRequest = ; // {GenerateCreateTableRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DDLTemplatesApi();
            var generateCreateTableRequest = new GenerateCreateTableRequest(); // GenerateCreateTableRequest | 

            try {
                GenerateCreateTableResponse result = apiInstance.createTable(generateCreateTableRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DDLTemplatesApi.createTable: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DDLTemplatesApi();
$generateCreateTableRequest = ; // GenerateCreateTableRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DDLTemplatesApi->new();
my $generateCreateTableRequest = WWW::OPenAPIClient::Object::GenerateCreateTableRequest->new(); # GenerateCreateTableRequest | 

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

try:
    api_response = api_instance.create_table(generateCreateTableRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DDLTemplatesApi->createTable: %s\n" % e)

extern crate DDLTemplatesApi;

pub fn main() {
    let generateCreateTableRequest = ; // GenerateCreateTableRequest

    let mut context = DDLTemplatesApi::Context::default();
    let result = client.createTable(generateCreateTableRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        DataFormatDto data = ; // DataFormatDto | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            DataFormatDto result = apiInstance.createDataFormat(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DataFormatDto data = new DataFormatDto(); // DataFormatDto | 
final File file = new File(); // File | 

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

import org.openapitools.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {
    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        DataFormatDto data = ; // DataFormatDto | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            DataFormatDto result = apiInstance.createDataFormat(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataFormatOperationsApi *apiInstance = [[DataFormatOperationsApi alloc] init];
DataFormatDto *data = ; //  (default to null)
File *file = BINARY_DATA_HERE; //  (optional) (default to null)

// Creates a Data Format.
[apiInstance createDataFormatWith:data
    file:file
              completionHandler: ^(DataFormatDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataFormatOperationsApi()
var data = ; // {DataFormatDto} 
var opts = {
  'file': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataFormatOperationsApi();
            var data = new DataFormatDto(); // DataFormatDto |  (default to null)
            var file = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                // Creates a Data Format.
                DataFormatDto result = apiInstance.createDataFormat(data, file);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.createDataFormat: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFormatOperationsApi();
$data = ; // DataFormatDto | 
$file = BINARY_DATA_HERE; // File | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFormatOperationsApi->new();
my $data = ; # DataFormatDto | 
my $file = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->createDataFormat(data => $data, file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->createDataFormat: $@\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.DataFormatOperationsApi()
data =  # DataFormatDto |  (default to null)
file = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    # Creates a Data Format.
    api_response = api_instance.create_data_format(data, file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->createDataFormat: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {
    let data = ; // DataFormatDto
    let file = BINARY_DATA_HERE; // File

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.createDataFormat(data, file, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 

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

import org.openapitools.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {
    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 

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

// Create an instance of the API class
DataFormatOperationsApi *apiInstance = [[DataFormatOperationsApi alloc] init];
Integer *id = 56; //  (default to null)

// Deletes a Data Format by ID.
[apiInstance deleteDataFormatByIdWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataFormatOperationsApi()
var id = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer |  (default to null)

            try {
                // Deletes a Data Format by ID.
                apiInstance.deleteDataFormatById(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.deleteDataFormatById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFormatOperationsApi();
$id = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFormatOperationsApi->new();
my $id = 56; # Integer | 

eval {
    $api_instance->deleteDataFormatById(id => $id);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->deleteDataFormatById: $@\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.DataFormatOperationsApi()
id = 56 # Integer |  (default to null)

try:
    # Deletes a Data Format by ID.
    api_instance.delete_data_format_by_id(id)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->deleteDataFormatById: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {
    let id = 56; // Integer

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.deleteDataFormatById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String type = type_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {
    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String type = type_example; // String | 

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

// Create an instance of the API class
DataFormatOperationsApi *apiInstance = [[DataFormatOperationsApi alloc] init];
String *type = type_example; //  (default to null)

// Deletes a Data Format by type.
[apiInstance deleteDataFormatByTypeWith:type
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataFormatOperationsApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataFormatOperationsApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Deletes a Data Format by type.
                apiInstance.deleteDataFormatByType(type);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.deleteDataFormatByType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFormatOperationsApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFormatOperationsApi->new();
my $type = type_example; # String | 

eval {
    $api_instance->deleteDataFormatByType(type => $type);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->deleteDataFormatByType: $@\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.DataFormatOperationsApi()
type = type_example # String |  (default to null)

try:
    # Deletes a Data Format by type.
    api_instance.delete_data_format_by_type(type)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->deleteDataFormatByType: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {
    let type = type_example; // String

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.deleteDataFormatByType(type, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 

        try {
            DataFormatDto result = apiInstance.getDataFormatById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 

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

import org.openapitools.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {
    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 

        try {
            DataFormatDto result = apiInstance.getDataFormatById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataFormatOperationsApi *apiInstance = [[DataFormatOperationsApi alloc] init];
Integer *id = 56; //  (default to null)

// Retrieves a Data Format by ID.
[apiInstance getDataFormatByIdWith:id
              completionHandler: ^(DataFormatDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataFormatOperationsApi()
var id = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer |  (default to null)

            try {
                // Retrieves a Data Format by ID.
                DataFormatDto result = apiInstance.getDataFormatById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.getDataFormatById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFormatOperationsApi();
$id = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFormatOperationsApi->new();
my $id = 56; # Integer | 

eval {
    my $result = $api_instance->getDataFormatById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatById: $@\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.DataFormatOperationsApi()
id = 56 # Integer |  (default to null)

try:
    # Retrieves a Data Format by ID.
    api_response = api_instance.get_data_format_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormatById: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {
    let id = 56; // Integer

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.getDataFormatById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String type = type_example; // String | 

        try {
            DataFormatDto result = apiInstance.getDataFormatByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatByType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {
    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String type = type_example; // String | 

        try {
            DataFormatDto result = apiInstance.getDataFormatByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatByType");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataFormatOperationsApi *apiInstance = [[DataFormatOperationsApi alloc] init];
String *type = type_example; //  (default to null)

// Retrieves a Connector by type.
[apiInstance getDataFormatByTypeWith:type
              completionHandler: ^(DataFormatDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataFormatOperationsApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataFormatOperationsApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Retrieves a Connector by type.
                DataFormatDto result = apiInstance.getDataFormatByType(type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.getDataFormatByType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFormatOperationsApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFormatOperationsApi->new();
my $type = type_example; # String | 

eval {
    my $result = $api_instance->getDataFormatByType(type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatByType: $@\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.DataFormatOperationsApi()
type = type_example # String |  (default to null)

try:
    # Retrieves a Connector by type.
    api_response = api_instance.get_data_format_by_type(type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormatByType: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {
    let type = type_example; // String

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.getDataFormatByType(type, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DataFormatOperationsApi;

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

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

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

// Retrieves all Data Formats.
[apiInstance getDataFormatsWithCompletionHandler: 
              ^(array[DataFormatDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Retrieves all Data Formats.
                array[DataFormatDto] result = apiInstance.getDataFormats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFormatOperationsApi.getDataFormats: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Retrieves all Data Formats.
    api_response = api_instance.get_data_formats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormats: %s\n" % e)

extern crate DataFormatOperationsApi;

pub fn main() {

    let mut context = DataFormatOperationsApi::Context::default();
    let result = client.getDataFormats(&context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 

        try {
            DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSourceV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String projectId = new String(); // String | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 

        try {
            DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSourceV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *id = id_example; //  (default to null)
String *projectId = projectId_example; //  (default to null)

// Creates a copy of a data source in the specified project.
[apiInstance copyDataSourceV2With:id
    projectId:projectId
              completionHandler: ^(DataSourceDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var id = id_example; // {String} 
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Creates a copy of a data source in the specified project.
                DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.copyDataSourceV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->copyDataSourceV2(id => $id, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->copyDataSourceV2: $@\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.DataSourceOperationsApi()
id = id_example # String |  (default to null)
projectId = projectId_example # String |  (default to null)

try:
    # Creates a copy of a data source in the specified project.
    api_response = api_instance.copy_data_source_v2(id, projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->copyDataSourceV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let id = id_example; // String
    let projectId = projectId_example; // String

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.copyDataSourceV2(id, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            DataSourceDto result = apiInstance.createDataSourceV2(projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSourceV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | 
final DataSourceSyncDto dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            DataSourceDto result = apiInstance.createDataSourceV2(projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSourceV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)
DataSourceSyncDto *dataSourceSyncDto = ; // 

// Creates a data source in the specified project.
[apiInstance createDataSourceV2With:projectId
    dataSourceSyncDto:dataSourceSyncDto
              completionHandler: ^(DataSourceDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var projectId = projectId_example; // {String} 
var dataSourceSyncDto = ; // {DataSourceSyncDto} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)
            var dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

            try {
                // Creates a data source in the specified project.
                DataSourceDto result = apiInstance.createDataSourceV2(projectId, dataSourceSyncDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.createDataSourceV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$projectId = projectId_example; // String | 
$dataSourceSyncDto = ; // DataSourceSyncDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 
my $dataSourceSyncDto = WWW::OPenAPIClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval {
    my $result = $api_instance->createDataSourceV2(projectId => $projectId, dataSourceSyncDto => $dataSourceSyncDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->createDataSourceV2: $@\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.DataSourceOperationsApi()
projectId = projectId_example # String |  (default to null)
dataSourceSyncDto =  # DataSourceSyncDto | 

try:
    # Creates a data source in the specified project.
    api_response = api_instance.create_data_source_v2(projectId, dataSourceSyncDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->createDataSourceV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String
    let dataSourceSyncDto = ; // DataSourceSyncDto

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.createDataSourceV2(projectId, dataSourceSyncDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        Boolean deleteDependents = true; // Boolean | 

        try {
            apiInstance.deleteDataSourceV2(id, projectId, deleteDependents);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#deleteDataSourceV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String projectId = new String(); // String | 
final Boolean deleteDependents = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        Boolean deleteDependents = true; // Boolean | 

        try {
            apiInstance.deleteDataSourceV2(id, projectId, deleteDependents);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#deleteDataSourceV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *id = id_example; //  (default to null)
String *projectId = projectId_example; //  (default to null)
Boolean *deleteDependents = true; //  (optional) (default to false)

// Deletes a data source from the specified project.
[apiInstance deleteDataSourceV2With:id
    projectId:projectId
    deleteDependents:deleteDependents
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var id = id_example; // {String} 
var projectId = projectId_example; // {String} 
var opts = {
  'deleteDependents': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)
            var deleteDependents = true;  // Boolean |  (optional)  (default to false)

            try {
                // Deletes a data source from the specified project.
                apiInstance.deleteDataSourceV2(id, projectId, deleteDependents);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.deleteDataSourceV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 
$deleteDependents = true; // Boolean | 

try {
    $api_instance->deleteDataSourceV2($id, $projectId, $deleteDependents);
} catch (Exception $e) {
    echo 'Exception when calling DataSourceOperationsApi->deleteDataSourceV2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 
my $deleteDependents = true; # Boolean | 

eval {
    $api_instance->deleteDataSourceV2(id => $id, projectId => $projectId, deleteDependents => $deleteDependents);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->deleteDataSourceV2: $@\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.DataSourceOperationsApi()
id = id_example # String |  (default to null)
projectId = projectId_example # String |  (default to null)
deleteDependents = true # Boolean |  (optional) (default to false)

try:
    # Deletes a data source from the specified project.
    api_instance.delete_data_source_v2(id, projectId, deleteDependents=deleteDependents)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->deleteDataSourceV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let id = id_example; // String
    let projectId = projectId_example; // String
    let deleteDependents = true; // Boolean

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.deleteDataSourceV2(id, projectId, deleteDependents, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 

        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectByIdV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String projectId = new String(); // String | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 

        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectByIdV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *id = id_example; //  (default to null)
String *projectId = projectId_example; //  (default to null)

// Retrieves a data source in the specified project by its id.
[apiInstance getDataSourceInProjectByIdV2With:id
    projectId:projectId
              completionHandler: ^(DataSourceDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var id = id_example; // {String} 
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Retrieves a data source in the specified project by its id.
                DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.getDataSourceInProjectByIdV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->getDataSourceInProjectByIdV2(id => $id, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getDataSourceInProjectByIdV2: $@\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.DataSourceOperationsApi()
id = id_example # String |  (default to null)
projectId = projectId_example # String |  (default to null)

try:
    # Retrieves a data source in the specified project by its id.
    api_response = api_instance.get_data_source_in_project_by_id_v2(id, projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getDataSourceInProjectByIdV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let id = id_example; // String
    let projectId = projectId_example; // String

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.getDataSourceInProjectByIdV2(id, projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)

// Retrieves all data sources in the specified project.
[apiInstance getDataSourcesInProjectV2With:projectId
              completionHandler: ^(array[DataSourceDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Retrieves all data sources in the specified project.
                array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.getDataSourcesInProjectV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->getDataSourcesInProjectV2(projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getDataSourcesInProjectV2: $@\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.DataSourceOperationsApi()
projectId = projectId_example # String |  (default to null)

try:
    # Retrieves all data sources in the specified project.
    api_response = api_instance.get_data_sources_in_project_v2(projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getDataSourcesInProjectV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.getDataSourcesInProjectV2(projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getKafkaSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 

        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getKafkaSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)

// Retrieves Kafka data sources in the specified project.
[apiInstance getKafkaSourcesInProjectV2With:projectId
              completionHandler: ^(array[DataSourceDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var projectId = projectId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)

            try {
                // Retrieves Kafka data sources in the specified project.
                array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.getKafkaSourcesInProjectV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$projectId = projectId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 

eval {
    my $result = $api_instance->getKafkaSourcesInProjectV2(projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getKafkaSourcesInProjectV2: $@\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.DataSourceOperationsApi()
projectId = projectId_example # String |  (default to null)

try:
    # Retrieves Kafka data sources in the specified project.
    api_response = api_instance.get_kafka_sources_in_project_v2(projectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getKafkaSourcesInProjectV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.getKafkaSourcesInProjectV2(projectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            DataSourceDto result = apiInstance.updateDataSourceV2(id, projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSourceV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String projectId = new String(); // String | 
final DataSourceSyncDto dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            DataSourceDto result = apiInstance.updateDataSourceV2(id, projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSourceV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *id = id_example; //  (default to null)
String *projectId = projectId_example; //  (default to null)
DataSourceSyncDto *dataSourceSyncDto = ; // 

// Updates an existing data source in the specified project.
[apiInstance updateDataSourceV2With:id
    projectId:projectId
    dataSourceSyncDto:dataSourceSyncDto
              completionHandler: ^(DataSourceDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var id = id_example; // {String} 
var projectId = projectId_example; // {String} 
var dataSourceSyncDto = ; // {DataSourceSyncDto} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String |  (default to null)
            var projectId = projectId_example;  // String |  (default to null)
            var dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

            try {
                // Updates an existing data source in the specified project.
                DataSourceDto result = apiInstance.updateDataSourceV2(id, projectId, dataSourceSyncDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.updateDataSourceV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 
$dataSourceSyncDto = ; // DataSourceSyncDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 
my $dataSourceSyncDto = WWW::OPenAPIClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval {
    my $result = $api_instance->updateDataSourceV2(id => $id, projectId => $projectId, dataSourceSyncDto => $dataSourceSyncDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->updateDataSourceV2: $@\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.DataSourceOperationsApi()
id = id_example # String |  (default to null)
projectId = projectId_example # String |  (default to null)
dataSourceSyncDto =  # DataSourceSyncDto | 

try:
    # Updates an existing data source in the specified project.
    api_response = api_instance.update_data_source_v2(id, projectId, dataSourceSyncDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->updateDataSourceV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let id = id_example; // String
    let projectId = projectId_example; // String
    let dataSourceSyncDto = ; // DataSourceSyncDto

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.updateDataSourceV2(id, projectId, dataSourceSyncDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSourceV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | 
final DataSourceSyncDto dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

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

import org.openapitools.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {
    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto dataSourceSyncDto = ; // DataSourceSyncDto | 

        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(projectId, dataSourceSyncDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSourceV2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DataSourceOperationsApi *apiInstance = [[DataSourceOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)
DataSourceSyncDto *dataSourceSyncDto = ; // 

// Validates a data source as a Flink catalog in the active project.
[apiInstance validateDataSourceV2With:projectId
    dataSourceSyncDto:dataSourceSyncDto
              completionHandler: ^(ValidateDataSourceResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.DataSourceOperationsApi()
var projectId = projectId_example; // {String} 
var dataSourceSyncDto = ; // {DataSourceSyncDto} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)
            var dataSourceSyncDto = new DataSourceSyncDto(); // DataSourceSyncDto | 

            try {
                // Validates a data source as a Flink catalog in the active project.
                ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(projectId, dataSourceSyncDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceOperationsApi.validateDataSourceV2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceOperationsApi();
$projectId = projectId_example; // String | 
$dataSourceSyncDto = ; // DataSourceSyncDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 
my $dataSourceSyncDto = WWW::OPenAPIClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval {
    my $result = $api_instance->validateDataSourceV2(projectId => $projectId, dataSourceSyncDto => $dataSourceSyncDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->validateDataSourceV2: $@\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.DataSourceOperationsApi()
projectId = projectId_example # String |  (default to null)
dataSourceSyncDto =  # DataSourceSyncDto | 

try:
    # Validates a data source as a Flink catalog in the active project.
    api_response = api_instance.validate_data_source_v2(projectId, dataSourceSyncDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->validateDataSourceV2: %s\n" % e)

extern crate DataSourceOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String
    let dataSourceSyncDto = ; // DataSourceSyncDto

    let mut context = DataSourceOperationsApi::Context::default();
    let result = client.validateDataSourceV2(projectId, dataSourceSyncDto, &context).wait();

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

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

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

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

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

        try {
            DatabaseConnectStringResponse result = apiInstance.connectString();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#connectString");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DatabaseInfoApi;

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

        try {
            DatabaseConnectStringResponse result = apiInstance.connectString();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#connectString");
            e.printStackTrace();
        }
    }
}

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

[apiInstance connectStringWithCompletionHandler: 
              ^(DatabaseConnectStringResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                DatabaseConnectStringResponse result = apiInstance.connectString();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseInfoApi.connectString: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.connect_string()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseInfoApi->connectString: %s\n" % e)

extern crate DatabaseInfoApi;

pub fn main() {

    let mut context = DatabaseInfoApi::Context::default();
    let result = client.connectString(&context).wait();

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

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

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

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

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

        try {
            DatabaseInfoResponse result = apiInstance.info();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#info");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DatabaseInfoApi;

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

        try {
            DatabaseInfoResponse result = apiInstance.info();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#info");
            e.printStackTrace();
        }
    }
}

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

[apiInstance infoWithCompletionHandler: 
              ^(DatabaseInfoResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                DatabaseInfoResponse result = apiInstance.info();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseInfoApi.info: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DatabaseInfoApi;

pub fn main() {

    let mut context = DatabaseInfoApi::Context::default();
    let result = client.info(&context).wait();

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

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

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

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

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

        try {
            DatabaseVersionResponse result = apiInstance.version();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#version");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DatabaseInfoApi;

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

        try {
            DatabaseVersionResponse result = apiInstance.version();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#version");
            e.printStackTrace();
        }
    }
}

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

[apiInstance versionWithCompletionHandler: 
              ^(DatabaseVersionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                DatabaseVersionResponse result = apiInstance.version();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseInfoApi.version: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DatabaseInfoApi;

pub fn main() {

    let mut context = DatabaseInfoApi::Context::default();
    let result = client.version(&context).wait();

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

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

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

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

        // Create an instance of the API class
        EventStreamTypeOperationsApi apiInstance = new EventStreamTypeOperationsApi();
        String sampleId = sampleId_example; // String | 
        Long kafkaPollTimeoutMillis = 789; // Long | Kafka poll timeout in ms.

        try {
            SseEmitter result = apiInstance.emitSampleStream(sampleId, kafkaPollTimeoutMillis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventStreamTypeOperationsApi#emitSampleStream");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String sampleId = new String(); // String | 
final Long kafkaPollTimeoutMillis = new Long(); // Long | Kafka poll timeout in ms.

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

import org.openapitools.client.api.EventStreamTypeOperationsApi;

public class EventStreamTypeOperationsApiExample {
    public static void main(String[] args) {
        EventStreamTypeOperationsApi apiInstance = new EventStreamTypeOperationsApi();
        String sampleId = sampleId_example; // String | 
        Long kafkaPollTimeoutMillis = 789; // Long | Kafka poll timeout in ms.

        try {
            SseEmitter result = apiInstance.emitSampleStream(sampleId, kafkaPollTimeoutMillis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventStreamTypeOperationsApi#emitSampleStream");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EventStreamTypeOperationsApi *apiInstance = [[EventStreamTypeOperationsApi alloc] init];
String *sampleId = sampleId_example; //  (default to null)
Long *kafkaPollTimeoutMillis = 789; // Kafka poll timeout in ms. (optional) (default to 1000)

// Polls job sample results in a streaming manner.
[apiInstance emitSampleStreamWith:sampleId
    kafkaPollTimeoutMillis:kafkaPollTimeoutMillis
              completionHandler: ^(SseEmitter output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.EventStreamTypeOperationsApi()
var sampleId = sampleId_example; // {String} 
var opts = {
  'kafkaPollTimeoutMillis': 789 // {Long} Kafka poll timeout in ms.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EventStreamTypeOperationsApi();
            var sampleId = sampleId_example;  // String |  (default to null)
            var kafkaPollTimeoutMillis = 789;  // Long | Kafka poll timeout in ms. (optional)  (default to 1000)

            try {
                // Polls job sample results in a streaming manner.
                SseEmitter result = apiInstance.emitSampleStream(sampleId, kafkaPollTimeoutMillis);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventStreamTypeOperationsApi.emitSampleStream: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventStreamTypeOperationsApi();
$sampleId = sampleId_example; // String | 
$kafkaPollTimeoutMillis = 789; // Long | Kafka poll timeout in ms.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventStreamTypeOperationsApi->new();
my $sampleId = sampleId_example; # String | 
my $kafkaPollTimeoutMillis = 789; # Long | Kafka poll timeout in ms.

eval {
    my $result = $api_instance->emitSampleStream(sampleId => $sampleId, kafkaPollTimeoutMillis => $kafkaPollTimeoutMillis);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventStreamTypeOperationsApi->emitSampleStream: $@\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.EventStreamTypeOperationsApi()
sampleId = sampleId_example # String |  (default to null)
kafkaPollTimeoutMillis = 789 # Long | Kafka poll timeout in ms. (optional) (default to 1000)

try:
    # Polls job sample results in a streaming manner.
    api_response = api_instance.emit_sample_stream(sampleId, kafkaPollTimeoutMillis=kafkaPollTimeoutMillis)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventStreamTypeOperationsApi->emitSampleStream: %s\n" % e)

extern crate EventStreamTypeOperationsApi;

pub fn main() {
    let sampleId = sampleId_example; // String
    let kafkaPollTimeoutMillis = 789; // Long

    let mut context = EventStreamTypeOperationsApi::Context::default();
    let result = client.emitSampleStream(sampleId, kafkaPollTimeoutMillis, &context).wait();

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

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

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

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

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

        try {
            array['String'] result = apiInstance.getCatalogConnectors();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkControllerApi#getCatalogConnectors");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkControllerApi;

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

        try {
            array['String'] result = apiInstance.getCatalogConnectors();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkControllerApi#getCatalogConnectors");
            e.printStackTrace();
        }
    }
}

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

// Retrieves all available Flink catalog connectors on the class path
[apiInstance getCatalogConnectorsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Retrieves all available Flink catalog connectors on the class path
                array['String'] result = apiInstance.getCatalogConnectors();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkControllerApi.getCatalogConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Retrieves all available Flink catalog connectors on the class path
    api_response = api_instance.get_catalog_connectors()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkControllerApi->getCatalogConnectors: %s\n" % e)

extern crate FlinkControllerApi;

pub fn main() {

    let mut context = FlinkControllerApi::Context::default();
    let result = client.getCatalogConnectors(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkDashboardApi;

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

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

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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_all_jobs_overview()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->getAllJobsOverview: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.getAllJobsOverview(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkDashboardApi;

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

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

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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_all_overview()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->getAllOverview: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.getAllOverview(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkDashboardApi;

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

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

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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_config()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->getConfig: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.getConfig(&context).wait();

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

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

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

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

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

        try {
            RedirectView result = apiInstance.redirectToIndex();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#redirectToIndex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkDashboardApi;

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

        try {
            RedirectView result = apiInstance.redirectToIndex();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#redirectToIndex");
            e.printStackTrace();
        }
    }
}

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

[apiInstance redirectToIndexWithCompletionHandler: 
              ^(RedirectView output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                RedirectView result = apiInstance.redirectToIndex();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.redirectToIndex: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.redirect_to_index()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->redirectToIndex: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.redirectToIndex(&context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest1(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest1(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest1(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest1(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest1: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request1(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest1: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest1(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest2(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest2(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest2(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest2(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest2: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request2(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest2: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest2(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest3(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest3");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest3(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest3");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest3(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest3: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest3(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest3: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request3(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest3: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest3(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest4(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest4");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest4(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest4");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest4(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest4: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest4(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest4: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request4(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest4: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest4(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest5(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest5");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest5(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest5");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest5(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest5: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest5(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest5: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request5(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest5: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest5(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest6(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest6");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = body_example; // String | 

        try {
            'String' result = apiInstance.routeJobRequest6(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest6");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *jobId = jobId_example; //  (default to null)
String *body = body_example; //  (optional)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var jobId = jobId_example; // {String} 
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                'String' result = apiInstance.routeJobRequest6(jobId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkDashboardApi.routeJobRequest6: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->routeJobRequest6(jobId => $jobId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeJobRequest6: $@\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.FlinkDashboardApi()
jobId = jobId_example # String |  (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.route_job_request6(jobId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeJobRequest6: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let jobId = jobId_example; // String
    let body = body_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeJobRequest6(jobId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest1(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest1: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request1(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest1: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest1(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest2(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest2: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request2(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest2: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest2(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest3(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest3: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request3(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest3: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest3(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest4(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest4: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request4(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest4: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest4(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest5(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest5: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request5(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest5: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest5(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {
    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 

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

// Create an instance of the API class
FlinkDashboardApi *apiInstance = [[FlinkDashboardApi alloc] init];
String *tmId = tmId_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkDashboardApi()
var tmId = tmId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkDashboardApi();
$tmId = tmId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 

eval {
    my $result = $api_instance->routeTaskRequest6(tmId => $tmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkDashboardApi->routeTaskRequest6: $@\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.FlinkDashboardApi()
tmId = tmId_example # String |  (default to null)

try:
    api_response = api_instance.route_task_request6(tmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest6: %s\n" % e)

extern crate FlinkDashboardApi;

pub fn main() {
    let tmId = tmId_example; // String

    let mut context = FlinkDashboardApi::Context::default();
    let result = client.routeTaskRequest6(tmId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FlinkJobOperationsApi apiInstance = new FlinkJobOperationsApi();
        String projectId = projectId_example; // String | 
        FlinkRunRequest flinkRunRequest = ; // FlinkRunRequest | 

        try {
            JarRunResponse result = apiInstance.run(projectId, flinkRunRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkJobOperationsApi#run");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | 
final FlinkRunRequest flinkRunRequest = new FlinkRunRequest(); // FlinkRunRequest | 

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

import org.openapitools.client.api.FlinkJobOperationsApi;

public class FlinkJobOperationsApiExample {
    public static void main(String[] args) {
        FlinkJobOperationsApi apiInstance = new FlinkJobOperationsApi();
        String projectId = projectId_example; // String | 
        FlinkRunRequest flinkRunRequest = ; // FlinkRunRequest | 

        try {
            JarRunResponse result = apiInstance.run(projectId, flinkRunRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkJobOperationsApi#run");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkJobOperationsApi *apiInstance = [[FlinkJobOperationsApi alloc] init];
String *projectId = projectId_example; //  (default to null)
FlinkRunRequest *flinkRunRequest = ; // 

// Run a Flink job from an uploaded artifact.
[apiInstance runWith:projectId
    flinkRunRequest:flinkRunRequest
              completionHandler: ^(JarRunResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkJobOperationsApi()
var projectId = projectId_example; // {String} 
var flinkRunRequest = ; // {FlinkRunRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FlinkJobOperationsApi();
            var projectId = projectId_example;  // String |  (default to null)
            var flinkRunRequest = new FlinkRunRequest(); // FlinkRunRequest | 

            try {
                // Run a Flink job from an uploaded artifact.
                JarRunResponse result = apiInstance.run(projectId, flinkRunRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkJobOperationsApi.run: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkJobOperationsApi();
$projectId = projectId_example; // String | 
$flinkRunRequest = ; // FlinkRunRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkJobOperationsApi->new();
my $projectId = projectId_example; # String | 
my $flinkRunRequest = WWW::OPenAPIClient::Object::FlinkRunRequest->new(); # FlinkRunRequest | 

eval {
    my $result = $api_instance->run(projectId => $projectId, flinkRunRequest => $flinkRunRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkJobOperationsApi->run: $@\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.FlinkJobOperationsApi()
projectId = projectId_example # String |  (default to null)
flinkRunRequest =  # FlinkRunRequest | 

try:
    # Run a Flink job from an uploaded artifact.
    api_response = api_instance.run(projectId, flinkRunRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkJobOperationsApi->run: %s\n" % e)

extern crate FlinkJobOperationsApi;

pub fn main() {
    let projectId = projectId_example; // String
    let flinkRunRequest = ; // FlinkRunRequest

    let mut context = FlinkJobOperationsApi::Context::default();
    let result = client.run(projectId, flinkRunRequest, &context).wait();

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

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

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

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

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

        try {
            FlinkSession result = apiInstance.getFlinkSessionByUserV2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#getFlinkSessionByUserV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkSessionClusterOperationsApi;

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

        try {
            FlinkSession result = apiInstance.getFlinkSessionByUserV2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#getFlinkSessionByUserV2");
            e.printStackTrace();
        }
    }
}

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

// Returns Flink session properties.
[apiInstance getFlinkSessionByUserV2WithCompletionHandler: 
              ^(FlinkSession output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Returns Flink session properties.
                FlinkSession result = apiInstance.getFlinkSessionByUserV2();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.getFlinkSessionByUserV2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Returns Flink session properties.
    api_response = api_instance.get_flink_session_by_user_v2()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->getFlinkSessionByUserV2: %s\n" % e)

extern crate FlinkSessionClusterOperationsApi;

pub fn main() {

    let mut context = FlinkSessionClusterOperationsApi::Context::default();
    let result = client.getFlinkSessionByUserV2(&context).wait();

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

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

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

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

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

        try {
            FlinkStatusDto result = apiInstance.provideFlinkSessionV2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#provideFlinkSessionV2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FlinkSessionClusterOperationsApi;

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

        try {
            FlinkStatusDto result = apiInstance.provideFlinkSessionV2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#provideFlinkSessionV2");
            e.printStackTrace();
        }
    }
}

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

// Ensures the Flink session exists and returns session properties.
[apiInstance provideFlinkSessionV2WithCompletionHandler: 
              ^(FlinkStatusDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

namespace Example
{
    public class provideFlinkSessionV2Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new FlinkSessionClusterOperationsApi();

            try {
                // Ensures the Flink session exists and returns session properties.
                FlinkStatusDto result = apiInstance.provideFlinkSessionV2();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.provideFlinkSessionV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkSessionClusterOperationsApi();

try {
    $result = $api_instance->provideFlinkSessionV2();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlinkSessionClusterOperationsApi->provideFlinkSessionV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FlinkSessionClusterOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkSessionClusterOperationsApi->new();

eval {
    my $result = $api_instance->provideFlinkSessionV2();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlinkSessionClusterOperationsApi->provideFlinkSessionV2: $@\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.FlinkSessionClusterOperationsApi()

try:
    # Ensures the Flink session exists and returns session properties.
    api_response = api_instance.provide_flink_session_v2()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->provideFlinkSessionV2: %s\n" % e)

extern crate FlinkSessionClusterOperationsApi;

pub fn main() {

    let mut context = FlinkSessionClusterOperationsApi::Context::default();
    let result = client.provideFlinkSessionV2(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FlinkSessionClusterOperationsApi;

import java.io.File;
import java.util.*;

public class FlinkSessionClusterOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        FlinkSessionClusterOperationsApi apiInstance = new FlinkSessionClusterOperationsApi();

        try {
            apiInstance.stopSessionCluster();
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#stopSessionCluster");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.stopSessionCluster();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->stopSessionCluster: $e\n');
}

import org.openapitools.client.api.FlinkSessionClusterOperationsApi;

public class FlinkSessionClusterOperationsApiExample {
    public static void main(String[] args) {
        FlinkSessionClusterOperationsApi apiInstance = new FlinkSessionClusterOperationsApi();

        try {
            apiInstance.stopSessionCluster();
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkSessionClusterOperationsApi#stopSessionCluster");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FlinkSessionClusterOperationsApi *apiInstance = [[FlinkSessionClusterOperationsApi alloc] init];

// Stops the running Flink Session Cluster of the user.
[apiInstance stopSessionClusterWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FlinkSessionClusterOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.stopSessionCluster(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class stopSessionClusterExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new FlinkSessionClusterOperationsApi();

            try {
                // Stops the running Flink Session Cluster of the user.
                apiInstance.stopSessionCluster();
            } catch (Exception e) {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.stopSessionCluster: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FlinkSessionClusterOperationsApi();

try {
    $api_instance->stopSessionCluster();
} catch (Exception $e) {
    echo 'Exception when calling FlinkSessionClusterOperationsApi->stopSessionCluster: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FlinkSessionClusterOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FlinkSessionClusterOperationsApi->new();

eval {
    $api_instance->stopSessionCluster();
};
if ($@) {
    warn "Exception when calling FlinkSessionClusterOperationsApi->stopSessionCluster: $@\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.FlinkSessionClusterOperationsApi()

try:
    # Stops the running Flink Session Cluster of the user.
    api_instance.stop_session_cluster()
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->stopSessionCluster: %s\n" % e)

extern crate FlinkSessionClusterOperationsApi;

pub fn main() {

    let mut context = FlinkSessionClusterOperationsApi::Context::default();
    let result = client.stopSessionCluster(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        array[GlobalConfigUpdateDto] globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

        try {
            array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#bulkUpdateGlobalConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[GlobalConfigUpdateDto] globalConfigUpdateDto = new array[GlobalConfigUpdateDto](); // array[GlobalConfigUpdateDto] | 

try {
    final result = await api_instance.bulkUpdateGlobalConfig(globalConfigUpdateDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkUpdateGlobalConfig: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        array[GlobalConfigUpdateDto] globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

        try {
            array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#bulkUpdateGlobalConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
array[GlobalConfigUpdateDto] *globalConfigUpdateDto = ; // 

// Bulk updates global configurations.
[apiInstance bulkUpdateGlobalConfigWith:globalConfigUpdateDto
              completionHandler: ^(array[GlobalConfigUpdateDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var globalConfigUpdateDto = ; // {array[GlobalConfigUpdateDto]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkUpdateGlobalConfig(globalConfigUpdateDto, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkUpdateGlobalConfigExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var globalConfigUpdateDto = new array[GlobalConfigUpdateDto](); // array[GlobalConfigUpdateDto] | 

            try {
                // Bulk updates global configurations.
                array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig(globalConfigUpdateDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.bulkUpdateGlobalConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

try {
    $result = $api_instance->bulkUpdateGlobalConfig($globalConfigUpdateDto);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $globalConfigUpdateDto = [WWW::OPenAPIClient::Object::array[GlobalConfigUpdateDto]->new()]; # array[GlobalConfigUpdateDto] | 

eval {
    my $result = $api_instance->bulkUpdateGlobalConfig(globalConfigUpdateDto => $globalConfigUpdateDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig: $@\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.GlobalConfigurationOperationsApi()
globalConfigUpdateDto =  # array[GlobalConfigUpdateDto] | 

try:
    # Bulk updates global configurations.
    api_response = api_instance.bulk_update_global_config(globalConfigUpdateDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto]

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.bulkUpdateGlobalConfig(globalConfigUpdateDto, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        array[GlobalConfigUpdateDto] globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

        try {
            array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig1(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#bulkUpdateGlobalConfig1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[GlobalConfigUpdateDto] globalConfigUpdateDto = new array[GlobalConfigUpdateDto](); // array[GlobalConfigUpdateDto] | 

try {
    final result = await api_instance.bulkUpdateGlobalConfig1(globalConfigUpdateDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkUpdateGlobalConfig1: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        array[GlobalConfigUpdateDto] globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

        try {
            array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig1(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#bulkUpdateGlobalConfig1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
array[GlobalConfigUpdateDto] *globalConfigUpdateDto = ; // 

// Bulk updates global configurations.
[apiInstance bulkUpdateGlobalConfig1With:globalConfigUpdateDto
              completionHandler: ^(array[GlobalConfigUpdateDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var globalConfigUpdateDto = ; // {array[GlobalConfigUpdateDto]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkUpdateGlobalConfig1(globalConfigUpdateDto, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkUpdateGlobalConfig1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var globalConfigUpdateDto = new array[GlobalConfigUpdateDto](); // array[GlobalConfigUpdateDto] | 

            try {
                // Bulk updates global configurations.
                array[GlobalConfigUpdateDto] result = apiInstance.bulkUpdateGlobalConfig1(globalConfigUpdateDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.bulkUpdateGlobalConfig1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto] | 

try {
    $result = $api_instance->bulkUpdateGlobalConfig1($globalConfigUpdateDto);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $globalConfigUpdateDto = [WWW::OPenAPIClient::Object::array[GlobalConfigUpdateDto]->new()]; # array[GlobalConfigUpdateDto] | 

eval {
    my $result = $api_instance->bulkUpdateGlobalConfig1(globalConfigUpdateDto => $globalConfigUpdateDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig1: $@\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.GlobalConfigurationOperationsApi()
globalConfigUpdateDto =  # array[GlobalConfigUpdateDto] | 

try:
    # Bulk updates global configurations.
    api_response = api_instance.bulk_update_global_config1(globalConfigUpdateDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig1: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let globalConfigUpdateDto = ; // array[GlobalConfigUpdateDto]

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.bulkUpdateGlobalConfig1(globalConfigUpdateDto, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String prefix = prefix_example; // String | 

        try {
            array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig(prefix);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getAllGlobalConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String prefix = new String(); // String | 

try {
    final result = await api_instance.getAllGlobalConfig(prefix);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllGlobalConfig: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String prefix = prefix_example; // String | 

        try {
            array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig(prefix);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getAllGlobalConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
String *prefix = prefix_example; //  (optional) (default to null)

// Retrieves all global configurations.
[apiInstance getAllGlobalConfigWith:prefix
              completionHandler: ^(array[GlobalConfigDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var opts = {
  'prefix': prefix_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllGlobalConfig(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getAllGlobalConfigExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var prefix = prefix_example;  // String |  (optional)  (default to null)

            try {
                // Retrieves all global configurations.
                array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig(prefix);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.getAllGlobalConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$prefix = prefix_example; // String | 

try {
    $result = $api_instance->getAllGlobalConfig($prefix);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $prefix = prefix_example; # String | 

eval {
    my $result = $api_instance->getAllGlobalConfig(prefix => $prefix);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig: $@\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.GlobalConfigurationOperationsApi()
prefix = prefix_example # String |  (optional) (default to null)

try:
    # Retrieves all global configurations.
    api_response = api_instance.get_all_global_config(prefix=prefix)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let prefix = prefix_example; // String

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.getAllGlobalConfig(prefix, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String prefix = prefix_example; // String | 

        try {
            array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig1(prefix);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getAllGlobalConfig1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String prefix = new String(); // String | 

try {
    final result = await api_instance.getAllGlobalConfig1(prefix);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllGlobalConfig1: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String prefix = prefix_example; // String | 

        try {
            array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig1(prefix);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getAllGlobalConfig1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
String *prefix = prefix_example; //  (optional) (default to null)

// Retrieves all global configurations.
[apiInstance getAllGlobalConfig1With:prefix
              completionHandler: ^(array[GlobalConfigDto] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var opts = {
  'prefix': prefix_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllGlobalConfig1(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getAllGlobalConfig1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var prefix = prefix_example;  // String |  (optional)  (default to null)

            try {
                // Retrieves all global configurations.
                array[GlobalConfigDto] result = apiInstance.getAllGlobalConfig1(prefix);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.getAllGlobalConfig1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$prefix = prefix_example; // String | 

try {
    $result = $api_instance->getAllGlobalConfig1($prefix);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $prefix = prefix_example; # String | 

eval {
    my $result = $api_instance->getAllGlobalConfig1(prefix => $prefix);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig1: $@\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.GlobalConfigurationOperationsApi()
prefix = prefix_example # String |  (optional) (default to null)

try:
    # Retrieves all global configurations.
    api_response = api_instance.get_all_global_config1(prefix=prefix)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->getAllGlobalConfig1: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let prefix = prefix_example; // String

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.getAllGlobalConfig1(prefix, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String key = key_example; // String | 

        try {
            GlobalConfigDto result = apiInstance.getGlobalConfigValue(key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getGlobalConfigValue");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String key = new String(); // String | 

try {
    final result = await api_instance.getGlobalConfigValue(key);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getGlobalConfigValue: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String key = key_example; // String | 

        try {
            GlobalConfigDto result = apiInstance.getGlobalConfigValue(key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getGlobalConfigValue");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
String *key = key_example; //  (default to null)

// Retrieves the global configuration of the given config key.
[apiInstance getGlobalConfigValueWith:key
              completionHandler: ^(GlobalConfigDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var key = key_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlobalConfigValue(key, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGlobalConfigValueExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var key = key_example;  // String |  (default to null)

            try {
                // Retrieves the global configuration of the given config key.
                GlobalConfigDto result = apiInstance.getGlobalConfigValue(key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.getGlobalConfigValue: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$key = key_example; // String | 

try {
    $result = $api_instance->getGlobalConfigValue($key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $key = key_example; # String | 

eval {
    my $result = $api_instance->getGlobalConfigValue(key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue: $@\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.GlobalConfigurationOperationsApi()
key = key_example # String |  (default to null)

try:
    # Retrieves the global configuration of the given config key.
    api_response = api_instance.get_global_config_value(key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let key = key_example; // String

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.getGlobalConfigValue(key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String key = key_example; // String | 

        try {
            GlobalConfigDto result = apiInstance.getGlobalConfigValue1(key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getGlobalConfigValue1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String key = new String(); // String | 

try {
    final result = await api_instance.getGlobalConfigValue1(key);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getGlobalConfigValue1: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        String key = key_example; // String | 

        try {
            GlobalConfigDto result = apiInstance.getGlobalConfigValue1(key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#getGlobalConfigValue1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
String *key = key_example; //  (default to null)

// Retrieves the global configuration of the given config key.
[apiInstance getGlobalConfigValue1With:key
              completionHandler: ^(GlobalConfigDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var key = key_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlobalConfigValue1(key, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGlobalConfigValue1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var key = key_example;  // String |  (default to null)

            try {
                // Retrieves the global configuration of the given config key.
                GlobalConfigDto result = apiInstance.getGlobalConfigValue1(key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.getGlobalConfigValue1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$key = key_example; // String | 

try {
    $result = $api_instance->getGlobalConfigValue1($key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $key = key_example; # String | 

eval {
    my $result = $api_instance->getGlobalConfigValue1(key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue1: $@\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.GlobalConfigurationOperationsApi()
key = key_example # String |  (default to null)

try:
    # Retrieves the global configuration of the given config key.
    api_response = api_instance.get_global_config_value1(key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->getGlobalConfigValue1: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let key = key_example; // String

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.getGlobalConfigValue1(key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        GlobalConfigUpdateDto globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

        try {
            GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#updateGlobalConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GlobalConfigUpdateDto globalConfigUpdateDto = new GlobalConfigUpdateDto(); // GlobalConfigUpdateDto | 

try {
    final result = await api_instance.updateGlobalConfig(globalConfigUpdateDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateGlobalConfig: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        GlobalConfigUpdateDto globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

        try {
            GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#updateGlobalConfig");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
GlobalConfigUpdateDto *globalConfigUpdateDto = ; // 

// Updates a global configuration.
[apiInstance updateGlobalConfigWith:globalConfigUpdateDto
              completionHandler: ^(GlobalConfigUpdateDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var globalConfigUpdateDto = ; // {GlobalConfigUpdateDto} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGlobalConfig(globalConfigUpdateDto, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateGlobalConfigExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var globalConfigUpdateDto = new GlobalConfigUpdateDto(); // GlobalConfigUpdateDto | 

            try {
                // Updates a global configuration.
                GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig(globalConfigUpdateDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.updateGlobalConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

try {
    $result = $api_instance->updateGlobalConfig($globalConfigUpdateDto);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $globalConfigUpdateDto = WWW::OPenAPIClient::Object::GlobalConfigUpdateDto->new(); # GlobalConfigUpdateDto | 

eval {
    my $result = $api_instance->updateGlobalConfig(globalConfigUpdateDto => $globalConfigUpdateDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig: $@\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.GlobalConfigurationOperationsApi()
globalConfigUpdateDto =  # GlobalConfigUpdateDto | 

try:
    # Updates a global configuration.
    api_response = api_instance.update_global_config(globalConfigUpdateDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let globalConfigUpdateDto = ; // GlobalConfigUpdateDto

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.updateGlobalConfig(globalConfigUpdateDto, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlobalConfigurationOperationsApi;

import java.io.File;
import java.util.*;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        GlobalConfigUpdateDto globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

        try {
            GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig1(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#updateGlobalConfig1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GlobalConfigUpdateDto globalConfigUpdateDto = new GlobalConfigUpdateDto(); // GlobalConfigUpdateDto | 

try {
    final result = await api_instance.updateGlobalConfig1(globalConfigUpdateDto);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateGlobalConfig1: $e\n');
}

import org.openapitools.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {
    public static void main(String[] args) {
        GlobalConfigurationOperationsApi apiInstance = new GlobalConfigurationOperationsApi();
        GlobalConfigUpdateDto globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

        try {
            GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig1(globalConfigUpdateDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalConfigurationOperationsApi#updateGlobalConfig1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlobalConfigurationOperationsApi *apiInstance = [[GlobalConfigurationOperationsApi alloc] init];
GlobalConfigUpdateDto *globalConfigUpdateDto = ; // 

// Updates a global configuration.
[apiInstance updateGlobalConfig1With:globalConfigUpdateDto
              completionHandler: ^(GlobalConfigUpdateDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GlobalConfigurationOperationsApi()
var globalConfigUpdateDto = ; // {GlobalConfigUpdateDto} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGlobalConfig1(globalConfigUpdateDto, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateGlobalConfig1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlobalConfigurationOperationsApi();
            var globalConfigUpdateDto = new GlobalConfigUpdateDto(); // GlobalConfigUpdateDto | 

            try {
                // Updates a global configuration.
                GlobalConfigUpdateDto result = apiInstance.updateGlobalConfig1(globalConfigUpdateDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.updateGlobalConfig1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlobalConfigurationOperationsApi();
$globalConfigUpdateDto = ; // GlobalConfigUpdateDto | 

try {
    $result = $api_instance->updateGlobalConfig1($globalConfigUpdateDto);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlobalConfigurationOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlobalConfigurationOperationsApi->new();
my $globalConfigUpdateDto = WWW::OPenAPIClient::Object::GlobalConfigUpdateDto->new(); # GlobalConfigUpdateDto | 

eval {
    my $result = $api_instance->updateGlobalConfig1(globalConfigUpdateDto => $globalConfigUpdateDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig1: $@\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.GlobalConfigurationOperationsApi()
globalConfigUpdateDto =  # GlobalConfigUpdateDto | 

try:
    # Updates a global configuration.
    api_response = api_instance.update_global_config1(globalConfigUpdateDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig1: %s\n" % e)

extern crate GlobalConfigurationOperationsApi;

pub fn main() {
    let globalConfigUpdateDto = ; // GlobalConfigUpdateDto

    let mut context = GlobalConfigurationOperationsApi::Context::default();
    let result = client.updateGlobalConfig1(globalConfigUpdateDto, &context).wait();

    println!("{:?}", result);
}