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

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

public class APIKeyOperationsApiExample {

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

import io.swagger.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {

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

ApiKeySyncDto *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.APIKeyOperationsApi()
var opts = { 
  'body':  // {{ApiKeySyncDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createApiKey(opts, callback);

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

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

            var apiInstance = new APIKeyOperationsApi();
            var body = new ApiKeySyncDto(); // ApiKeySyncDto |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$body = ; // ApiKeySyncDto | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
body =  # ApiKeySyncDto |  (optional)

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

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

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

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 
        ApiKeySyncDto body = ; // ApiKeySyncDto | 
        try {
            ApiKeyDto result = apiInstance.createApiKey1(projectId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        String projectId = projectId_example; // String | 
        ApiKeySyncDto body = ; // ApiKeySyncDto | 
        try {
            ApiKeyDto result = apiInstance.createApiKey1(projectId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey1");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
ApiKeySyncDto *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.APIKeyOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{ApiKeySyncDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createApiKey1(projectId, opts, callback);

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

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

            var apiInstance = new APIKeyOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new ApiKeySyncDto(); // ApiKeySyncDto |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // ApiKeySyncDto | 

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

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

my $api_instance = WWW::SwaggerClient::APIKeyOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::ApiKeySyncDto->new(); # ApiKeySyncDto | 

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

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
projectId = projectId_example # String | 
body =  # ApiKeySyncDto |  (optional)

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

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

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

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.deleteApiKeyById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.deleteApiKeyById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.APIKeyOperationsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer | 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$id = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->deleteApiKeyById(id => $id);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->deleteApiKeyById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
id = 56 # Integer | 

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

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

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

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.deleteApiKeyById1(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById1");
            e.printStackTrace();
        }
    }
}

import io.swagger.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.deleteApiKeyById1(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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.deleteApiKeyById1(id, projectId, callback);

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

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

            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer | 
            var projectId = projectId_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$id = 56; // Integer | 
$projectId = projectId_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->deleteApiKeyById1(id => $id, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling APIKeyOperationsApi->deleteApiKeyById1: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
id = 56 # Integer | 
projectId = projectId_example # String | 

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

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

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

public class APIKeyOperationsApiExample {

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

import io.swagger.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {

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

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

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

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

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

            var apiInstance = new APIKeyOperationsApi();

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

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

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

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

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

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

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

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

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

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *projectId = projectId_example; // 

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

// 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 SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new APIKeyOperationsApi();
            var projectId = projectId_example;  // String | 

            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');

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIKeyOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
projectId = projectId_example # String | 

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)

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

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

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.APIKeyOperationsApi;

public class APIKeyOperationsApiExample {

    public static void main(String[] args) {
        APIKeyOperationsApi apiInstance = new APIKeyOperationsApi();
        Integer id = 56; // Integer | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.APIKeyOperationsApi()
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.getApiKeyById(id, callback);

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

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

            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer | 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$id = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 

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

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
id = 56 # Integer | 

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

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

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

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.getApiKeyById1(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById1");
            e.printStackTrace();
        }
    }
}

import io.swagger.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.getApiKeyById1(id, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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.getApiKeyById1(id, projectId, callback);

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

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

            var apiInstance = new APIKeyOperationsApi();
            var id = 56;  // Integer | 
            var projectId = projectId_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiAPIKeyOperationsApi();
$id = 56; // Integer | 
$projectId = projectId_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::APIKeyOperationsApi->new();
my $id = 56; # Integer | 
my $projectId = projectId_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.APIKeyOperationsApi()
id = 56 # Integer | 
projectId = projectId_example # String | 

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

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

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

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        GenerateKeytabRequest body = ; // GenerateKeytabRequest | 
        try {
            apiInstance.generateKeytab(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        GenerateKeytabRequest body = ; // GenerateKeytabRequest | 
        try {
            apiInstance.generateKeytab(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // 
GenerateKeytabRequest *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.AdminOperationsApi()
var userId = userId_example; // {{String}} 
var opts = { 
  'body':  // {{GenerateKeytabRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.generateKeytab(userId, opts, callback);

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

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

            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String | 
            var body = new GenerateKeytabRequest(); // GenerateKeytabRequest |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAdminOperationsApi();
$userId = userId_example; // String | 
$body = ; // GenerateKeytabRequest | 

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

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

my $api_instance = WWW::SwaggerClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $body = WWW::SwaggerClient::Object::GenerateKeytabRequest->new(); # GenerateKeytabRequest | 

eval { 
    $api_instance->generateKeytab(userId => $userId, body => $body);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->generateKeytab: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AdminOperationsApi()
userId = userId_example # String | 
body =  # GenerateKeytabRequest |  (optional)

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

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

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

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        UpdatePasswordRequest body = ; // UpdatePasswordRequest | 
        try {
            apiInstance.updateUserPassword(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        UpdatePasswordRequest body = ; // UpdatePasswordRequest | 
        try {
            apiInstance.updateUserPassword(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // 
UpdatePasswordRequest *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.AdminOperationsApi()
var userId = userId_example; // {{String}} 
var opts = { 
  'body':  // {{UpdatePasswordRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateUserPassword(userId, opts, callback);

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

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

            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String | 
            var body = new UpdatePasswordRequest(); // UpdatePasswordRequest |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAdminOperationsApi();
$userId = userId_example; // String | 
$body = ; // UpdatePasswordRequest | 

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

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

my $api_instance = WWW::SwaggerClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $body = WWW::SwaggerClient::Object::UpdatePasswordRequest->new(); # UpdatePasswordRequest | 

eval { 
    $api_instance->updateUserPassword(userId => $userId, body => $body);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->updateUserPassword: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AdminOperationsApi()
userId = userId_example # String | 
body =  # UpdatePasswordRequest |  (optional)

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

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

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

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        Keytab_upload_body body = ; // Keytab_upload_body | 
        try {
            apiInstance.uploadKeytab(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

    public static void main(String[] args) {
        AdminOperationsApi apiInstance = new AdminOperationsApi();
        String userId = userId_example; // String | 
        Keytab_upload_body body = ; // Keytab_upload_body | 
        try {
            apiInstance.uploadKeytab(userId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // 
Keytab_upload_body *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.AdminOperationsApi()
var userId = userId_example; // {{String}} 
var opts = { 
  'body':  // {{Keytab_upload_body}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.uploadKeytab(userId, opts, callback);

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

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

            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String | 
            var body = new Keytab_upload_body(); // Keytab_upload_body |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAdminOperationsApi();
$userId = userId_example; // String | 
$body = ; // Keytab_upload_body | 

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

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

my $api_instance = WWW::SwaggerClient::AdminOperationsApi->new();
my $userId = userId_example; # String | 
my $body = WWW::SwaggerClient::Object::Keytab_upload_body->new(); # Keytab_upload_body | 

eval { 
    $api_instance->uploadKeytab(userId => $userId, body => $body);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->uploadKeytab: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AdminOperationsApi()
userId = userId_example # String | 
body =  # Keytab_upload_body |  (optional)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            apiInstance.deleteArtifact(artifactName, scope);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifact");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            apiInstance.deleteArtifact(artifactName, scope);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifact");
            e.printStackTrace();
        }
    }
}

String *artifactName = artifactName_example; //  (optional)
String *scope = scope_example; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'artifactName': artifactName_example, // {{String}} 
  'scope': scope_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteArtifact(opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var artifactName = artifactName_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$artifactName = artifactName_example; // String | 
$scope = scope_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $artifactName = artifactName_example; # String | 
my $scope = scope_example; # String | 

eval { 
    $api_instance->deleteArtifact(artifactName => $artifactName, scope => $scope);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->deleteArtifact: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
artifactName = artifactName_example # String |  (optional)
scope = scope_example # String |  (optional)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String body = ; // String | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        try {
            apiInstance.deleteArtifactV2(body, name, scope);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifactV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String body = ; // String | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        try {
            apiInstance.deleteArtifactV2(body, name, scope);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifactV2");
            e.printStackTrace();
        }
    }
}

String *body = ; //  (optional)
String *name = name_example; //  (optional)
String *scope = scope_example; //  (optional) (default to USER)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'body':  // {{String}} 
  'name': name_example // {{String}} 
  'scope': scope_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteArtifactV2(opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var body = new String(); // String |  (optional) 
            var name = name_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional)  (default to USER)

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$body = ; // String | 
$name = name_example; // String | 
$scope = scope_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 
my $name = name_example; # String | 
my $scope = scope_example; # String | 

eval { 
    $api_instance->deleteArtifactV2(body => $body, name => $name, scope => $scope);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->deleteArtifactV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
body =  # String |  (optional)
name = name_example # String |  (optional)
scope = scope_example # String |  (optional) (default to USER)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifact(artifactName, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifact");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifact(artifactName, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifact");
            e.printStackTrace();
        }
    }
}

String *artifactName = artifactName_example; //  (optional)
String *scope = scope_example; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'artifactName': artifactName_example, // {{String}} 
  'scope': scope_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getArtifact(opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var artifactName = artifactName_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$artifactName = artifactName_example; // String | 
$scope = scope_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $artifactName = artifactName_example; # String | 
my $scope = scope_example; # String | 

eval { 
    my $result = $api_instance->getArtifact(artifactName => $artifactName, scope => $scope);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->getArtifact: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
artifactName = artifactName_example # String |  (optional)
scope = scope_example # String |  (optional)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String body = ; // String | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(body, name, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifactV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        String body = ; // String | 
        String name = name_example; // String | 
        String scope = scope_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(body, name, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifactV2");
            e.printStackTrace();
        }
    }
}

String *body = ; //  (optional)
String *name = name_example; //  (optional)
String *scope = scope_example; //  (optional) (default to USER)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'body':  // {{String}} 
  'name': name_example // {{String}} 
  'scope': scope_example // {{String}} 
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ArtifactOperationsApi();
            var body = new String(); // String |  (optional) 
            var name = name_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional)  (default to USER)

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$body = ; // String | 
$name = name_example; // String | 
$scope = scope_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 
my $name = name_example; # String | 
my $scope = scope_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
body =  # String |  (optional)
name = name_example # String |  (optional)
scope = scope_example # String |  (optional) (default to USER)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        byte[] file = file_example; // byte[] | 
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifact(file, artifactName, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifact");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        byte[] file = file_example; // byte[] | 
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifact(file, artifactName, scope);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifact");
            e.printStackTrace();
        }
    }
}

byte[] *file = file_example; //  (optional)
String *artifactName = artifactName_example; //  (optional)
String *scope = scope_example; //  (optional) (default to USER)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'file': file_example // {{byte[]}} 
  'artifactName': artifactName_example // {{String}} 
  'scope': scope_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadArtifact(opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var file = file_example;  // byte[] |  (optional) 
            var artifactName = artifactName_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional)  (default to USER)

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$file = file_example; // byte[] | 
$artifactName = artifactName_example; // String | 
$scope = scope_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $file = file_example; # byte[] | 
my $artifactName = artifactName_example; # String | 
my $scope = scope_example; # String | 

eval { 
    my $result = $api_instance->uploadArtifact(file => $file, artifactName => $artifactName, scope => $scope);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->uploadArtifact: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
file = file_example # byte[] |  (optional)
artifactName = artifactName_example # String |  (optional)
scope = scope_example # String |  (optional) (default to USER)

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

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

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

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        UploadArtifactRequest data = ; // UploadArtifactRequest | 
        byte[] file = file_example; // byte[] | 
        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifactV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ArtifactOperationsApi;

public class ArtifactOperationsApiExample {

    public static void main(String[] args) {
        ArtifactOperationsApi apiInstance = new ArtifactOperationsApi();
        UploadArtifactRequest data = ; // UploadArtifactRequest | 
        byte[] file = file_example; // byte[] | 
        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(data, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#uploadArtifactV2");
            e.printStackTrace();
        }
    }
}

UploadArtifactRequest *data = ; //  (optional)
byte[] *file = file_example; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ArtifactOperationsApi()
var opts = { 
  'data':  // {{UploadArtifactRequest}} 
  'file': file_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadArtifactV2(opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var data = new UploadArtifactRequest(); // UploadArtifactRequest |  (optional) 
            var file = file_example;  // byte[] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiArtifactOperationsApi();
$data = ; // UploadArtifactRequest | 
$file = file_example; // byte[] | 

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

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

my $api_instance = WWW::SwaggerClient::ArtifactOperationsApi->new();
my $data = ; # UploadArtifactRequest | 
my $file = file_example; # byte[] | 

eval { 
    my $result = $api_instance->uploadArtifactV2(data => $data, file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ArtifactOperationsApi->uploadArtifactV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ArtifactOperationsApi()
data =  # UploadArtifactRequest |  (optional)
file = file_example # byte[] |  (optional)

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

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

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

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        ConnectorDto data = ; // ConnectorDto | 
        byte[] file = file_example; // byte[] | 
        try {
            apiInstance.createConnector(data, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        ConnectorDto data = ; // ConnectorDto | 
        byte[] file = file_example; // byte[] | 
        try {
            apiInstance.createConnector(data, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector");
            e.printStackTrace();
        }
    }
}

ConnectorDto *data = ; //  (optional)
byte[] *file = file_example; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ConnectorOperationsApi()
var opts = { 
  'data':  // {{ConnectorDto}} 
  'file': file_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createConnector(opts, callback);

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

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

            var apiInstance = new ConnectorOperationsApi();
            var data = new ConnectorDto(); // ConnectorDto |  (optional) 
            var file = file_example;  // byte[] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$data = ; // ConnectorDto | 
$file = file_example; // byte[] | 

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

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

my $api_instance = WWW::SwaggerClient::ConnectorOperationsApi->new();
my $data = ; # ConnectorDto | 
my $file = file_example; # byte[] | 

eval { 
    $api_instance->createConnector(data => $data, file => $file);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->createConnector: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
data =  # ConnectorDto |  (optional)
file = file_example # byte[] |  (optional)

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer | 

            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');

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConnectorOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
id = 56 # Integer | 

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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *type = type_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String | 

            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');

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConnectorOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
type = type_example # String | 

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)

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

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

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.getConnectorById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.getConnectorById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ConnectorOperationsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer | 

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

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

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$id = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::ConnectorOperationsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->getConnectorById(id => $id);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
id = 56 # Integer | 

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

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

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

public class ConnectorOperationsApiExample {

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

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

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

String *type = type_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 

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

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

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

            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$type = type_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::ConnectorOperationsApi->new();
my $type = type_example; # String | 

eval { 
    $api_instance->getConnectorByType(type => $type);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorByType: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
type = type_example # String | 

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

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

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

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 
        Jar_type_body body = ; // Jar_type_body | 
        try {
            apiInstance.getConnectorJarFile(type, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorJarFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String type = type_example; // String | 
        Jar_type_body body = ; // Jar_type_body | 
        try {
            apiInstance.getConnectorJarFile(type, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorJarFile");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
Jar_type_body *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'body':  // {{Jar_type_body}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConnectorJarFile(type, opts, callback);

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

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

            var apiInstance = new ConnectorOperationsApi();
            var type = type_example;  // String | 
            var body = new Jar_type_body(); // Jar_type_body |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$type = type_example; // String | 
$body = ; // Jar_type_body | 

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

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

my $api_instance = WWW::SwaggerClient::ConnectorOperationsApi->new();
my $type = type_example; # String | 
my $body = WWW::SwaggerClient::Object::Jar_type_body->new(); # Jar_type_body | 

eval { 
    $api_instance->getConnectorJarFile(type => $type, body => $body);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorJarFile: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ConnectorOperationsApi()
type = type_example # String | 
body =  # Jar_type_body |  (optional)

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

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

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

public class ConnectorOperationsApiExample {

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

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

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

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.ConnectorOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConnectors(callback);

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

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

            var apiInstance = new ConnectorOperationsApi();

            try
            {
                // Retrieves all connectors.
                apiInstance.getConnectors();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConnectorOperationsApi.getConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

public class DDLTemplatesApiExample {

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

import io.swagger.client.api.DDLTemplatesApi;

public class DDLTemplatesApiExample {

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

GenerateCreateTableRequest *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DDLTemplatesApi()
var opts = { 
  'body':  // {{GenerateCreateTableRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createTable(opts, callback);

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

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

            var apiInstance = new DDLTemplatesApi();
            var body = new GenerateCreateTableRequest(); // GenerateCreateTableRequest |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDDLTemplatesApi();
$body = ; // GenerateCreateTableRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.DDLTemplatesApi()
body =  # GenerateCreateTableRequest |  (optional)

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

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

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

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        DataFormatDto data = ; // DataFormatDto | 
        byte[] file = file_example; // byte[] | 
        try {
            apiInstance.createDataFormat(data, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        DataFormatDto data = ; // DataFormatDto | 
        byte[] file = file_example; // byte[] | 
        try {
            apiInstance.createDataFormat(data, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat");
            e.printStackTrace();
        }
    }
}

DataFormatDto *data = ; //  (optional)
byte[] *file = file_example; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataFormatOperationsApi()
var opts = { 
  'data': , // {{DataFormatDto}} 
  'file': file_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createDataFormat(opts, callback);

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

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

            var apiInstance = new DataFormatOperationsApi();
            var data = new DataFormatDto(); // DataFormatDto |  (optional) 
            var file = file_example;  // byte[] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$data = ; // DataFormatDto | 
$file = file_example; // byte[] | 

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

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

my $api_instance = WWW::SwaggerClient::DataFormatOperationsApi->new();
my $data = ; # DataFormatDto | 
my $file = file_example; # byte[] | 

eval { 
    $api_instance->createDataFormat(data => $data, file => $file);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->createDataFormat: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataFormatOperationsApi()
data =  # DataFormatDto |  (optional)
file = file_example # byte[] |  (optional)

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer | 

            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');

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataFormatOperationsApi()
id = 56 # Integer | 

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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *type = type_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DataFormatOperationsApi();
            var type = type_example;  // String | 

            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');

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataFormatOperationsApi()
type = type_example # String | 

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)

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

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

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.getDataFormatById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.getDataFormatById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataFormatOperationsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer | 

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

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

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$id = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::DataFormatOperationsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->getDataFormatById(id => $id);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataFormatOperationsApi()
id = 56 # Integer | 

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

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

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

public class DataFormatOperationsApiExample {

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

import io.swagger.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {

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

String *type = type_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataFormatOperationsApi()
var type = type_example; // {{String}} 

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

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

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

            var apiInstance = new DataFormatOperationsApi();
            var type = type_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$type = type_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DataFormatOperationsApi->new();
my $type = type_example; # String | 

eval { 
    $api_instance->getDataFormatByType(type => $type);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatByType: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataFormatOperationsApi()
type = type_example # String | 

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

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

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

public class DataFormatOperationsApiExample {

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

import io.swagger.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {

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

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataFormatOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getDataFormats(callback);

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

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

            var apiInstance = new DataFormatOperationsApi();

            try
            {
                // Retrieves all Data Formats.
                apiInstance.getDataFormats();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatOperationsApi.getDataFormats: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

String *id = id_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 

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

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

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

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

            try
            {
                // Creates a copy of a data source in the active project.
                apiInstance.copyDataSource(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.copyDataSource: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->copyDataSource(id => $id);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->copyDataSource: $@\n";
}

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

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

try: 
    # Creates a copy of a data source in the active project.
    api_instance.copy_data_source(id)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->copyDataSource: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.copyDataSourceV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSourceV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            apiInstance.copyDataSourceV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSourceV2");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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.');
  }
};
api.copyDataSourceV2(id, projectId, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var projectId = projectId_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 

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

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

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

eval { 
    $api_instance->copyDataSourceV2(id => $id, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->copyDataSourceV2: $@\n";
}

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

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

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

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

DataSourceDto *body = ; //  (optional)

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

// Creates a data source in the active project.
[apiInstance createDataSourceWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var opts = { 
  'body':  // {{DataSourceDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createDataSource(opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var body = new DataSourceDto(); // DataSourceDto |  (optional) 

            try
            {
                // Creates a data source in the active project.
                apiInstance.createDataSource(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.createDataSource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$body = ; // DataSourceDto | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
body =  # DataSourceDto |  (optional)

try: 
    # Creates a data source in the active project.
    api_instance.create_data_source(body=body)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->createDataSource: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        try {
            apiInstance.createDataSourceV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSourceV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        try {
            apiInstance.createDataSourceV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSourceV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
DataSourceSyncDto *body = ; //  (optional)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{DataSourceSyncDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createDataSourceV2(projectId, opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new DataSourceSyncDto(); // DataSourceSyncDto |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // DataSourceSyncDto | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval { 
    $api_instance->createDataSourceV2(projectId => $projectId, body => $body);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->createDataSourceV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
projectId = projectId_example # String | 
body =  # DataSourceSyncDto |  (optional)

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

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        Boolean deleteDependents = true; // Boolean | 
        try {
            apiInstance.deleteDataSource(id, deleteDependents);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#deleteDataSource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        Boolean deleteDependents = true; // Boolean | 
        try {
            apiInstance.deleteDataSource(id, deleteDependents);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#deleteDataSource");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
Boolean *deleteDependents = true; //  (optional) (default to false)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var id = id_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.deleteDataSource(id, opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var deleteDependents = true;  // Boolean |  (optional)  (default to false)

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

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$id = id_example; // String | 
$deleteDependents = true; // Boolean | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $deleteDependents = true; # Boolean | 

eval { 
    $api_instance->deleteDataSource(id => $id, deleteDependents => $deleteDependents);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->deleteDataSource: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
id = id_example # String | 
deleteDependents = true # Boolean |  (optional) (default to false)

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 
Boolean *deleteDependents = true; //  (optional) (default to false)

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var projectId = projectId_example;  // String | 
            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');

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataSourceOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
id = id_example # String | 
projectId = projectId_example # String | 
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)

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

String *id = id_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 

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

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

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

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

            try
            {
                // Retrieves a data source in the active project by its id.
                apiInstance.getDataSourceInProjectById(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.getDataSourceInProjectById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    $api_instance->getDataSourceInProjectById(id => $id);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getDataSourceInProjectById: $@\n";
}

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

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

try: 
    # Retrieves a data source in the active project by its id.
    api_instance.get_data_source_in_project_by_id(id)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getDataSourceInProjectById: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.getDataSourceInProjectByIdV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectByIdV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            apiInstance.getDataSourceInProjectByIdV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectByIdV2");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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.');
  }
};
api.getDataSourceInProjectByIdV2(id, projectId, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var projectId = projectId_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 

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

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

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

eval { 
    $api_instance->getDataSourceInProjectByIdV2(id => $id, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getDataSourceInProjectByIdV2: $@\n";
}

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

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

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

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

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

// Retrieves all data sources in the active project.
[apiInstance getDataSourcesInProjectWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getDataSourcesInProject(callback);

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

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

            var apiInstance = new DataSourceOperationsApi();

            try
            {
                // Retrieves all data sources in the active project.
                apiInstance.getDataSourcesInProject();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.getDataSourcesInProject: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Retrieves all data sources in the active project.
    api_instance.get_data_sources_in_project()
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getDataSourcesInProject: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 

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

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

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

            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$projectId = projectId_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->getDataSourcesInProjectV2(projectId => $projectId);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getDataSourcesInProjectV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
projectId = projectId_example # String | 

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

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

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

// Retrieves Kafka data sources in the active project.
[apiInstance getKafkaSourcesInProjectWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getKafkaSourcesInProject(callback);

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

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

            var apiInstance = new DataSourceOperationsApi();

            try
            {
                // Retrieves Kafka data sources in the active project.
                apiInstance.getKafkaSourcesInProject();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.getKafkaSourcesInProject: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Retrieves Kafka data sources in the active project.
    api_instance.get_kafka_sources_in_project()
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getKafkaSourcesInProject: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

String *projectId = projectId_example; // 

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 

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

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

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

            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String | 

            try
            {
                // Retrieves Kafka data sources in the specified project.
                apiInstance.getKafkaSourcesInProjectV2(projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.getKafkaSourcesInProjectV2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$projectId = projectId_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->getKafkaSourcesInProjectV2(projectId => $projectId);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->getKafkaSourcesInProjectV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
projectId = projectId_example # String | 

try: 
    # Retrieves Kafka data sources in the specified project.
    api_instance.get_kafka_sources_in_project_v2(projectId)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->getKafkaSourcesInProjectV2: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        DataSourceDto body = ; // DataSourceDto | 
        try {
            apiInstance.updateDataSource(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        DataSourceDto body = ; // DataSourceDto | 
        try {
            apiInstance.updateDataSource(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSource");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
DataSourceDto *body = ; //  (optional)

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

// Updates an existing data source in the active project.
[apiInstance updateDataSourceWith:id
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var opts = { 
  'body':  // {{DataSourceDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateDataSource(id, opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var body = new DataSourceDto(); // DataSourceDto |  (optional) 

            try
            {
                // Updates an existing data source in the active project.
                apiInstance.updateDataSource(id, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.updateDataSource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$id = id_example; // String | 
$body = ; // DataSourceDto | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::DataSourceDto->new(); # DataSourceDto | 

eval { 
    $api_instance->updateDataSource(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->updateDataSource: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
id = id_example # String | 
body =  # DataSourceDto |  (optional)

try: 
    # Updates an existing data source in the active project.
    api_instance.update_data_source(id, body=body)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->updateDataSource: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        try {
            apiInstance.updateDataSourceV2(id, projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSourceV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 body = ; // DataSourceSyncDto | 
        try {
            apiInstance.updateDataSourceV2(id, projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSourceV2");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 
DataSourceSyncDto *body = ; //  (optional)

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

// Updates an existing data source in the specified project.
[apiInstance updateDataSourceV2With:id
    projectId:projectId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{DataSourceSyncDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateDataSourceV2(idprojectId, opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var id = id_example;  // String | 
            var projectId = projectId_example;  // String | 
            var body = new DataSourceSyncDto(); // DataSourceSyncDto |  (optional) 

            try
            {
                // Updates an existing data source in the specified project.
                apiInstance.updateDataSourceV2(id, projectId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.updateDataSourceV2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$id = id_example; // String | 
$projectId = projectId_example; // String | 
$body = ; // DataSourceSyncDto | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval { 
    $api_instance->updateDataSourceV2(id => $id, projectId => $projectId, body => $body);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->updateDataSourceV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
id = id_example # String | 
projectId = projectId_example # String | 
body =  # DataSourceSyncDto |  (optional)

try: 
    # Updates an existing data source in the specified project.
    api_instance.update_data_source_v2(id, projectId, body=body)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->updateDataSourceV2: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

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

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

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

DataSourceDto *body = ; //  (optional)

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

// Validates a data source as a Flink catalog in the active project.
[apiInstance validateDataSourceWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var opts = { 
  'body':  // {{DataSourceDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.validateDataSource(opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var body = new DataSourceDto(); // DataSourceDto |  (optional) 

            try
            {
                // Validates a data source as a Flink catalog in the active project.
                apiInstance.validateDataSource(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.validateDataSource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$body = ; // DataSourceDto | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
body =  # DataSourceDto |  (optional)

try: 
    # Validates a data source as a Flink catalog in the active project.
    api_instance.validate_data_source(body=body)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->validateDataSource: %s\n" % e)

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

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

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        try {
            apiInstance.validateDataSourceV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSourceV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataSourceOperationsApi;

public class DataSourceOperationsApiExample {

    public static void main(String[] args) {
        DataSourceOperationsApi apiInstance = new DataSourceOperationsApi();
        String projectId = projectId_example; // String | 
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        try {
            apiInstance.validateDataSourceV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSourceV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
DataSourceSyncDto *body = ; //  (optional)

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

// Validates a data source as a Flink catalog in the active project.
[apiInstance validateDataSourceV2With:projectId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{DataSourceSyncDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.validateDataSourceV2(projectId, opts, callback);

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

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

            var apiInstance = new DataSourceOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new DataSourceSyncDto(); // DataSourceSyncDto |  (optional) 

            try
            {
                // Validates a data source as a Flink catalog in the active project.
                apiInstance.validateDataSourceV2(projectId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataSourceOperationsApi.validateDataSourceV2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDataSourceOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // DataSourceSyncDto | 

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

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

my $api_instance = WWW::SwaggerClient::DataSourceOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 

eval { 
    $api_instance->validateDataSourceV2(projectId => $projectId, body => $body);
};
if ($@) {
    warn "Exception when calling DataSourceOperationsApi->validateDataSourceV2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DataSourceOperationsApi()
projectId = projectId_example # String | 
body =  # DataSourceSyncDto |  (optional)

try: 
    # Validates a data source as a Flink catalog in the active project.
    api_instance.validate_data_source_v2(projectId, body=body)
except ApiException as e:
    print("Exception when calling DataSourceOperationsApi->validateDataSourceV2: %s\n" % e)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatabaseInfoApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatabaseInfoApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatabaseInfoApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

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

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

public class EventSteamTypeOperationsApiExample {

    public static void main(String[] args) {
        
        EventSteamTypeOperationsApi apiInstance = new EventSteamTypeOperationsApi();
        String sampleId = sampleId_example; // String | 
        Long timeout = 789; // Long | Kafka poll timeout in ms.
        try {
            apiInstance.emitSampleStream(sampleId, timeout);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventSteamTypeOperationsApi#emitSampleStream");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventSteamTypeOperationsApi;

public class EventSteamTypeOperationsApiExample {

    public static void main(String[] args) {
        EventSteamTypeOperationsApi apiInstance = new EventSteamTypeOperationsApi();
        String sampleId = sampleId_example; // String | 
        Long timeout = 789; // Long | Kafka poll timeout in ms.
        try {
            apiInstance.emitSampleStream(sampleId, timeout);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventSteamTypeOperationsApi#emitSampleStream");
            e.printStackTrace();
        }
    }
}

String *sampleId = sampleId_example; // 
Long *timeout = 789; // Kafka poll timeout in ms. (optional) (default to 1000)

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

// Polls job sample results in a streaming manner.
[apiInstance emitSampleStreamWith:sampleId
    timeout:timeout
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.EventSteamTypeOperationsApi()
var sampleId = sampleId_example; // {{String}} 
var opts = { 
  'timeout': 789 // {{Long}} Kafka poll timeout in ms.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.emitSampleStream(sampleId, opts, callback);

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

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

            var apiInstance = new EventSteamTypeOperationsApi();
            var sampleId = sampleId_example;  // String | 
            var timeout = 789;  // Long | Kafka poll timeout in ms. (optional)  (default to 1000)

            try
            {
                // Polls job sample results in a streaming manner.
                apiInstance.emitSampleStream(sampleId, timeout);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventSteamTypeOperationsApi.emitSampleStream: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEventSteamTypeOperationsApi();
$sampleId = sampleId_example; // String | 
$timeout = 789; // Long | Kafka poll timeout in ms.

try {
    $api_instance->emitSampleStream($sampleId, $timeout);
} catch (Exception $e) {
    echo 'Exception when calling EventSteamTypeOperationsApi->emitSampleStream: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventSteamTypeOperationsApi->new();
my $sampleId = sampleId_example; # String | 
my $timeout = 789; # Long | Kafka poll timeout in ms.

eval { 
    $api_instance->emitSampleStream(sampleId => $sampleId, timeout => $timeout);
};
if ($@) {
    warn "Exception when calling EventSteamTypeOperationsApi->emitSampleStream: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EventSteamTypeOperationsApi()
sampleId = sampleId_example # String | 
timeout = 789 # Long | Kafka poll timeout in ms. (optional) (default to 1000)

try: 
    # Polls job sample results in a streaming manner.
    api_instance.emit_sample_stream(sampleId, timeout=timeout)
except ApiException as e:
    print("Exception when calling EventSteamTypeOperationsApi->emitSampleStream: %s\n" % e)

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

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

public class FlinkControllerApiExample {

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

import io.swagger.client.api.FlinkControllerApi;

public class FlinkControllerApiExample {

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

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

// Retrieves all available Flink catalog connectors on the class path
[apiInstance getCatalogConnectorsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCatalogConnectors(callback);

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

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

            var apiInstance = new FlinkControllerApi();

            try
            {
                // Retrieves all available Flink catalog connectors on the class path
                apiInstance.getCatalogConnectors();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkControllerApi.getCatalogConnectors: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Retrieves all available Flink catalog connectors on the class path
    api_instance.get_catalog_connectors()
except ApiException as e:
    print("Exception when calling FlinkControllerApi->getCatalogConnectors: %s\n" % e)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlinkDashboardApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlinkDashboardApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlinkDashboardApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

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

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

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            RedirectView result = apiInstance.redirectToIndex(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#redirectToIndex");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            RedirectView result = apiInstance.redirectToIndex(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#redirectToIndex");
            e.printStackTrace();
        }
    }
}

map[String, Object] *body = ; //  (optional)

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

[apiInstance redirectToIndexWith:body
              completionHandler: ^(RedirectView output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkDashboardApi()
var opts = { 
  'body':  // {{map[String, Object]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.redirectToIndex(opts, callback);

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

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

            var apiInstance = new FlinkDashboardApi();
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

            try
            {
                RedirectView result = apiInstance.redirectToIndex(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkDashboardApi.redirectToIndex: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlinkDashboardApi();
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::FlinkDashboardApi->new();
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlinkDashboardApi()
body =  # map[String, Object] |  (optional)

try: 
    api_response = api_instance.redirect_to_index(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->redirectToIndex: %s\n" % e)

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

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

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = ; // String | 
        try {
            ResponseEntity result = apiInstance.routeJobRequest(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String jobId = jobId_example; // String | 
        String body = ; // String | 
        try {
            ResponseEntity result = apiInstance.routeJobRequest(jobId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeJobRequest");
            e.printStackTrace();
        }
    }
}

String *jobId = jobId_example; // 
String *body = ; //  (optional)

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

[apiInstance routeJobRequestWith:jobId
    body:body
              completionHandler: ^(ResponseEntity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkDashboardApi()
var jobId = jobId_example; // {{String}} 
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlinkDashboardApi();
            var jobId = jobId_example;  // String | 
            var body = new String(); // String |  (optional) 

            try
            {
                ResponseEntity 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');

$api_instance = new Swagger\Client\ApiFlinkDashboardApi();
$jobId = jobId_example; // String | 
$body = ; // 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::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlinkDashboardApi;

my $api_instance = WWW::SwaggerClient::FlinkDashboardApi->new();
my $jobId = jobId_example; # String | 
my $body = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlinkDashboardApi()
jobId = jobId_example # String | 
body =  # 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)

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

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

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 
        String body = ; // String | 
        try {
            ResponseEntity result = apiInstance.routeTaskRequest(tmId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeTaskRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlinkDashboardApi;

public class FlinkDashboardApiExample {

    public static void main(String[] args) {
        FlinkDashboardApi apiInstance = new FlinkDashboardApi();
        String tmId = tmId_example; // String | 
        String body = ; // String | 
        try {
            ResponseEntity result = apiInstance.routeTaskRequest(tmId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkDashboardApi#routeTaskRequest");
            e.printStackTrace();
        }
    }
}

String *tmId = tmId_example; // 
String *body = ; //  (optional)

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

[apiInstance routeTaskRequestWith:tmId
    body:body
              completionHandler: ^(ResponseEntity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkDashboardApi()
var tmId = tmId_example; // {{String}} 
var opts = { 
  'body':  // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.routeTaskRequest(tmId, opts, callback);

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

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

            var apiInstance = new FlinkDashboardApi();
            var tmId = tmId_example;  // String | 
            var body = new String(); // String |  (optional) 

            try
            {
                ResponseEntity result = apiInstance.routeTaskRequest(tmId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkDashboardApi.routeTaskRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlinkDashboardApi();
$tmId = tmId_example; // String | 
$body = ; // String | 

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

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

my $api_instance = WWW::SwaggerClient::FlinkDashboardApi->new();
my $tmId = tmId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlinkDashboardApi()
tmId = tmId_example # String | 
body =  # String |  (optional)

try: 
    api_response = api_instance.route_task_request(tmId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkDashboardApi->routeTaskRequest: %s\n" % e)

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

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

public class FlinkJobOperationsApiExample {

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

import io.swagger.client.api.FlinkJobOperationsApi;

public class FlinkJobOperationsApiExample {

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

FlinkRunRequest *body = ; //  (optional)

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

// Run a Flink job from an uploaded artifact.
[apiInstance runWith:body
              completionHandler: ^(JarRunResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkJobOperationsApi()
var opts = { 
  'body':  // {{FlinkRunRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.run(opts, callback);

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

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

            var apiInstance = new FlinkJobOperationsApi();
            var body = new FlinkRunRequest(); // FlinkRunRequest |  (optional) 

            try
            {
                // Run a Flink job from an uploaded artifact.
                JarRunResponse result = apiInstance.run(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkJobOperationsApi.run: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlinkJobOperationsApi();
$body = ; // FlinkRunRequest | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.FlinkJobOperationsApi()
body =  # FlinkRunRequest |  (optional)

try: 
    # Run a Flink job from an uploaded artifact.
    api_response = api_instance.run(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkJobOperationsApi->run: %s\n" % e)

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

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

public class FlinkJobOperationsApiExample {

    public static void main(String[] args) {
        
        FlinkJobOperationsApi apiInstance = new FlinkJobOperationsApi();
        String projectId = projectId_example; // String | 
        FlinkRunRequest body = ; // FlinkRunRequest | 
        try {
            JarRunResponse result = apiInstance.run1(projectId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkJobOperationsApi#run1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlinkJobOperationsApi;

public class FlinkJobOperationsApiExample {

    public static void main(String[] args) {
        FlinkJobOperationsApi apiInstance = new FlinkJobOperationsApi();
        String projectId = projectId_example; // String | 
        FlinkRunRequest body = ; // FlinkRunRequest | 
        try {
            JarRunResponse result = apiInstance.run1(projectId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlinkJobOperationsApi#run1");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
FlinkRunRequest *body = ; //  (optional)

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

// Run a Flink job from an uploaded artifact.
[apiInstance run1With:projectId
    body:body
              completionHandler: ^(JarRunResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkJobOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{FlinkRunRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.run1(projectId, opts, callback);

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

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

            var apiInstance = new FlinkJobOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new FlinkRunRequest(); // FlinkRunRequest |  (optional) 

            try
            {
                // Run a Flink job from an uploaded artifact.
                JarRunResponse result = apiInstance.run1(projectId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkJobOperationsApi.run1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFlinkJobOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // FlinkRunRequest | 

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

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

my $api_instance = WWW::SwaggerClient::FlinkJobOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::FlinkRunRequest->new(); # FlinkRunRequest | 

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

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

# create an instance of the API class
api_instance = swagger_client.FlinkJobOperationsApi()
projectId = projectId_example # String | 
body =  # FlinkRunRequest |  (optional)

try: 
    # Run a Flink job from an uploaded artifact.
    api_response = api_instance.run1(projectId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlinkJobOperationsApi->run1: %s\n" % e)

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

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

public class FlinkSessionClusterOperationsApiExample {

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

import io.swagger.client.api.FlinkSessionClusterOperationsApi;

public class FlinkSessionClusterOperationsApiExample {

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

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

// Returns Flink session properties.
[apiInstance getFlinkSessionByUserWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkSessionClusterOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getFlinkSessionByUser(callback);

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

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

            var apiInstance = new FlinkSessionClusterOperationsApi();

            try
            {
                // Returns Flink session properties.
                apiInstance.getFlinkSessionByUser();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.getFlinkSessionByUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Returns Flink session properties.
    api_instance.get_flink_session_by_user()
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->getFlinkSessionByUser: %s\n" % e)

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

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

public class FlinkSessionClusterOperationsApiExample {

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

import io.swagger.client.api.FlinkSessionClusterOperationsApi;

public class FlinkSessionClusterOperationsApiExample {

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

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

// Returns Flink session properties.
[apiInstance getFlinkSessionByUserV2WithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkSessionClusterOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getFlinkSessionByUserV2(callback);

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

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

            var apiInstance = new FlinkSessionClusterOperationsApi();

            try
            {
                // Returns Flink session properties.
                apiInstance.getFlinkSessionByUserV2();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.getFlinkSessionByUserV2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Returns Flink session properties.
    api_instance.get_flink_session_by_user_v2()
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->getFlinkSessionByUserV2: %s\n" % e)

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

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

public class FlinkSessionClusterOperationsApiExample {

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

import io.swagger.client.api.FlinkSessionClusterOperationsApi;

public class FlinkSessionClusterOperationsApiExample {

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

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

// Ensures the Flink session exists and returns session properties.
[apiInstance provideFlinkSessionWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkSessionClusterOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.provideFlinkSession(callback);

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

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

            var apiInstance = new FlinkSessionClusterOperationsApi();

            try
            {
                // Ensures the Flink session exists and returns session properties.
                apiInstance.provideFlinkSession();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.provideFlinkSession: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Ensures the Flink session exists and returns session properties.
    api_instance.provide_flink_session()
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->provideFlinkSession: %s\n" % e)

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

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

public class FlinkSessionClusterOperationsApiExample {

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

import io.swagger.client.api.FlinkSessionClusterOperationsApi;

public class FlinkSessionClusterOperationsApiExample {

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

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

// Ensures the Flink session exists and returns session properties.
[apiInstance provideFlinkSessionV2WithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.FlinkSessionClusterOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.provideFlinkSessionV2(callback);

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

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

            var apiInstance = new FlinkSessionClusterOperationsApi();

            try
            {
                // Ensures the Flink session exists and returns session properties.
                apiInstance.provideFlinkSessionV2();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlinkSessionClusterOperationsApi.provideFlinkSessionV2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    # Ensures the Flink session exists and returns session properties.
    api_instance.provide_flink_session_v2()
except ApiException as e:
    print("Exception when calling FlinkSessionClusterOperationsApi->provideFlinkSessionV2: %s\n" % e)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

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

// Stops the running Flink Session Cluster of the user.
[apiInstance stopSessionClusterWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.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)

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

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

public class GlobalConfigurationOperationsApiExample {

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

import io.swagger.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {

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

array[GlobalConfigUpdateDto] *body = ; //  (optional)

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

// Bulk updates global configurations.
[apiInstance bulkUpdateGlobalConfigWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.GlobalConfigurationOperationsApi()
var opts = { 
  'body':  // {{array[GlobalConfigUpdateDto]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.bulkUpdateGlobalConfig(opts, callback);

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

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

            var apiInstance = new GlobalConfigurationOperationsApi();
            var body = new array[GlobalConfigUpdateDto](); // array[GlobalConfigUpdateDto] |  (optional) 

            try
            {
                // Bulk updates global configurations.
                apiInstance.bulkUpdateGlobalConfig(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.bulkUpdateGlobalConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlobalConfigurationOperationsApi();
$body = ; // array[GlobalConfigUpdateDto] | 

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

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

my $api_instance = WWW::SwaggerClient::GlobalConfigurationOperationsApi->new();
my $body = [WWW::SwaggerClient::Object::array[GlobalConfigUpdateDto]->new()]; # array[GlobalConfigUpdateDto] | 

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

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

# create an instance of the API class
api_instance = swagger_client.GlobalConfigurationOperationsApi()
body =  # array[GlobalConfigUpdateDto] |  (optional)

try: 
    # Bulk updates global configurations.
    api_instance.bulk_update_global_config(body=body)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->bulkUpdateGlobalConfig: %s\n" % e)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *prefix = prefix_example; //  (optional)

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

// Retrieves all global configurations.
[apiInstance getAllGlobalConfigWith:prefix
              completionHandler: ^(array[GlobalConfigDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlobalConfigurationOperationsApi();
            var prefix = prefix_example;  // String |  (optional) 

            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');

$api_instance = new Swagger\Client\ApiGlobalConfigurationOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlobalConfigurationOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.GlobalConfigurationOperationsApi()
prefix = prefix_example # String |  (optional)

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)

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

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *key = key_example; // 

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

// 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 SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlobalConfigurationOperationsApi();
            var key = key_example;  // String | 

            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');

$api_instance = new Swagger\Client\ApiGlobalConfigurationOperationsApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlobalConfigurationOperationsApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.GlobalConfigurationOperationsApi()
key = key_example # String | 

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)

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

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

public class GlobalConfigurationOperationsApiExample {

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

import io.swagger.client.api.GlobalConfigurationOperationsApi;

public class GlobalConfigurationOperationsApiExample {

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

GlobalConfigUpdateDto *body = ; //  (optional)

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

// Updates a global configuration.
[apiInstance updateGlobalConfigWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.GlobalConfigurationOperationsApi()
var opts = { 
  'body':  // {{GlobalConfigUpdateDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateGlobalConfig(opts, callback);

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

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

            var apiInstance = new GlobalConfigurationOperationsApi();
            var body = new GlobalConfigUpdateDto(); // GlobalConfigUpdateDto |  (optional) 

            try
            {
                // Updates a global configuration.
                apiInstance.updateGlobalConfig(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlobalConfigurationOperationsApi.updateGlobalConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlobalConfigurationOperationsApi();
$body = ; // GlobalConfigUpdateDto | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.GlobalConfigurationOperationsApi()
body =  # GlobalConfigUpdateDto |  (optional)

try: 
    # Updates a global configuration.
    api_instance.update_global_config(body=body)
except ApiException as e:
    print("Exception when calling GlobalConfigurationOperationsApi->updateGlobalConfig: %s\n" % e)

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

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

public class HeartbeatApiExample {

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

import io.swagger.client.api.HeartbeatApi;

public class HeartbeatApiExample {

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

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

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

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.HeartbeatApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.heartbeat(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class heartbeatExample
    {
        public void main()
        {

            var apiInstance = new HeartbeatApi();

            try
            {
                apiInstance.heartbeat();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HeartbeatApi.heartbeat: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHeartbeatApi();

try {
    $api_instance->heartbeat();
} catch (Exception $e) {
    echo 'Exception when calling HeartbeatApi->heartbeat: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HeartbeatApi;

my $api_instance = WWW::SwaggerClient::HeartbeatApi->new();

eval { 
    $api_instance->heartbeat();
};
if ($@) {
    warn "Exception when calling HeartbeatApi->heartbeat: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.HeartbeatApi()

try: 
    api_instance.heartbeat()
except ApiException as e:
    print("Exception when calling HeartbeatApi->heartbeat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HistoryControllerApi;

import java.io.File;
import java.util.*;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        String projectId = projectId_example; // String | 
        try {
            apiInstance.deleteHistoryAllByProjectId(projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#deleteHistoryAllByProjectId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HistoryControllerApi;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        String projectId = projectId_example; // String | 
        try {
            apiInstance.deleteHistoryAllByProjectId(projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#deleteHistoryAllByProjectId");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; //  (optional)

HistoryControllerApi *apiInstance = [[HistoryControllerApi alloc] init];

[apiInstance deleteHistoryAllByProjectIdWith:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.HistoryControllerApi()
var opts = { 
  'projectId': projectId_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteHistoryAllByProjectId(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteHistoryAllByProjectIdExample
    {
        public void main()
        {

            var apiInstance = new HistoryControllerApi();
            var projectId = projectId_example;  // String |  (optional) 

            try
            {
                apiInstance.deleteHistoryAllByProjectId(projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HistoryControllerApi.deleteHistoryAllByProjectId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHistoryControllerApi();
$projectId = projectId_example; // String | 

try {
    $api_instance->deleteHistoryAllByProjectId($projectId);
} catch (Exception $e) {
    echo 'Exception when calling HistoryControllerApi->deleteHistoryAllByProjectId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HistoryControllerApi;

my $api_instance = WWW::SwaggerClient::HistoryControllerApi->new();
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->deleteHistoryAllByProjectId(projectId => $projectId);
};
if ($@) {
    warn "Exception when calling HistoryControllerApi->deleteHistoryAllByProjectId: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.HistoryControllerApi()
projectId = projectId_example # String |  (optional)

try: 
    api_instance.delete_history_all_by_project_id(projectId=projectId)
except ApiException as e:
    print("Exception when calling HistoryControllerApi->deleteHistoryAllByProjectId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HistoryControllerApi;

import java.io.File;
import java.util.*;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.deleteHistoryById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#deleteHistoryById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HistoryControllerApi;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.deleteHistoryById(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#deleteHistoryById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

HistoryControllerApi *apiInstance = [[HistoryControllerApi alloc] init];

[apiInstance deleteHistoryByIdWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.HistoryControllerApi()
var id = 56; // {{Integer}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteHistoryById(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteHistoryByIdExample
    {
        public void main()
        {

            var apiInstance = new HistoryControllerApi();
            var id = 56;  // Integer | 

            try
            {
                apiInstance.deleteHistoryById(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HistoryControllerApi.deleteHistoryById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHistoryControllerApi();
$id = 56; // Integer | 

try {
    $api_instance->deleteHistoryById($id);
} catch (Exception $e) {
    echo 'Exception when calling HistoryControllerApi->deleteHistoryById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HistoryControllerApi;

my $api_instance = WWW::SwaggerClient::HistoryControllerApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->deleteHistoryById(id => $id);
};
if ($@) {
    warn "Exception when calling HistoryControllerApi->deleteHistoryById: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.HistoryControllerApi()
id = 56 # Integer | 

try: 
    api_instance.delete_history_by_id(id)
except ApiException as e:
    print("Exception when calling HistoryControllerApi->deleteHistoryById: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HistoryControllerApi;

import java.io.File;
import java.util.*;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        try {
            array[HistoryItemDto] result = apiInstance.getItemsForProject();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#getItemsForProject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HistoryControllerApi;

public class HistoryControllerApiExample {

    public static void main(String[] args) {
        HistoryControllerApi apiInstance = new HistoryControllerApi();
        try {
            array[HistoryItemDto] result = apiInstance.getItemsForProject();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryControllerApi#getItemsForProject");
            e.printStackTrace();
        }
    }
}

HistoryControllerApi *apiInstance = [[HistoryControllerApi alloc] init];

[apiInstance getItemsForProjectWithCompletionHandler: 
              ^(array[HistoryItemDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.HistoryControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getItemsForProject(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getItemsForProjectExample
    {
        public void main()
        {

            var apiInstance = new HistoryControllerApi();

            try
            {
                array[HistoryItemDto] result = apiInstance.getItemsForProject();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HistoryControllerApi.getItemsForProject: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHistoryControllerApi();

try {
    $result = $api_instance->getItemsForProject();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HistoryControllerApi->getItemsForProject: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HistoryControllerApi;

my $api_instance = WWW::SwaggerClient::HistoryControllerApi->new();

eval { 
    my $result = $api_instance->getItemsForProject();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HistoryControllerApi->getItemsForProject: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.HistoryControllerApi()

try: 
    api_response = api_instance.get_items_for_project()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HistoryControllerApi->getItemsForProject: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobNotificationActionOperationsApi;

import java.io.File;
import java.util.*;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer groupId = 56; // Integer | 
        Integer childId = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.addToJobNotificationGroupV2(groupId, childId, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#addToJobNotificationGroupV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobNotificationActionOperationsApi;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer groupId = 56; // Integer | 
        Integer childId = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.addToJobNotificationGroupV2(groupId, childId, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#addToJobNotificationGroupV2");
            e.printStackTrace();
        }
    }
}

Integer *groupId = 56; // 
Integer *childId = 56; // 
String *projectId = projectId_example; // 

JobNotificationActionOperationsApi *apiInstance = [[JobNotificationActionOperationsApi alloc] init];

// Adds a Notification Action or Group to a Notification Group
[apiInstance addToJobNotificationGroupV2With:groupId
    childId:childId
    projectId:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.JobNotificationActionOperationsApi()
var groupId = 56; // {{Integer}} 
var childId = 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.addToJobNotificationGroupV2(groupId, childId, projectId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addToJobNotificationGroupV2Example
    {
        public void main()
        {

            var apiInstance = new JobNotificationActionOperationsApi();
            var groupId = 56;  // Integer | 
            var childId = 56;  // Integer | 
            var projectId = projectId_example;  // String | 

            try
            {
                // Adds a Notification Action or Group to a Notification Group
                apiInstance.addToJobNotificationGroupV2(groupId, childId, projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobNotificationActionOperationsApi.addToJobNotificationGroupV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobNotificationActionOperationsApi();
$groupId = 56; // Integer | 
$childId = 56; // Integer | 
$projectId = projectId_example; // String | 

try {
    $api_instance->addToJobNotificationGroupV2($groupId, $childId, $projectId);
} catch (Exception $e) {
    echo 'Exception when calling JobNotificationActionOperationsApi->addToJobNotificationGroupV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobNotificationActionOperationsApi;

my $api_instance = WWW::SwaggerClient::JobNotificationActionOperationsApi->new();
my $groupId = 56; # Integer | 
my $childId = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->addToJobNotificationGroupV2(groupId => $groupId, childId => $childId, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling JobNotificationActionOperationsApi->addToJobNotificationGroupV2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobNotificationActionOperationsApi()
groupId = 56 # Integer | 
childId = 56 # Integer | 
projectId = projectId_example # String | 

try: 
    # Adds a Notification Action or Group to a Notification Group
    api_instance.add_to_job_notification_group_v2(groupId, childId, projectId)
except ApiException as e:
    print("Exception when calling JobNotificationActionOperationsApi->addToJobNotificationGroupV2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobNotificationActionOperationsApi;

import java.io.File;
import java.util.*;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        String projectId = projectId_example; // String | 
        CreateNotificationGroupRequest body = ; // CreateNotificationGroupRequest | 
        try {
            apiInstance.createJobNotificationGroupV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#createJobNotificationGroupV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobNotificationActionOperationsApi;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        String projectId = projectId_example; // String | 
        CreateNotificationGroupRequest body = ; // CreateNotificationGroupRequest | 
        try {
            apiInstance.createJobNotificationGroupV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#createJobNotificationGroupV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
CreateNotificationGroupRequest *body = ; //  (optional)

JobNotificationActionOperationsApi *apiInstance = [[JobNotificationActionOperationsApi alloc] init];

// Creates a new Job Notification Group.
[apiInstance createJobNotificationGroupV2With:projectId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.JobNotificationActionOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{CreateNotificationGroupRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createJobNotificationGroupV2(projectId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createJobNotificationGroupV2Example
    {
        public void main()
        {

            var apiInstance = new JobNotificationActionOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new CreateNotificationGroupRequest(); // CreateNotificationGroupRequest |  (optional) 

            try
            {
                // Creates a new Job Notification Group.
                apiInstance.createJobNotificationGroupV2(projectId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobNotificationActionOperationsApi.createJobNotificationGroupV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobNotificationActionOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // CreateNotificationGroupRequest | 

try {
    $api_instance->createJobNotificationGroupV2($projectId, $body);
} catch (Exception $e) {
    echo 'Exception when calling JobNotificationActionOperationsApi->createJobNotificationGroupV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobNotificationActionOperationsApi;

my $api_instance = WWW::SwaggerClient::JobNotificationActionOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::CreateNotificationGroupRequest->new(); # CreateNotificationGroupRequest | 

eval { 
    $api_instance->createJobNotificationGroupV2(projectId => $projectId, body => $body);
};
if ($@) {
    warn "Exception when calling JobNotificationActionOperationsApi->createJobNotificationGroupV2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobNotificationActionOperationsApi()
projectId = projectId_example # String | 
body =  # CreateNotificationGroupRequest |  (optional)

try: 
    # Creates a new Job Notification Group.
    api_instance.create_job_notification_group_v2(projectId, body=body)
except ApiException as e:
    print("Exception when calling JobNotificationActionOperationsApi->createJobNotificationGroupV2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobNotificationActionOperationsApi;

import java.io.File;
import java.util.*;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        String projectId = projectId_example; // String | 
        CreateNotificationActionRequest body = ; // CreateNotificationActionRequest | 
        try {
            apiInstance.createJobNotificationV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#createJobNotificationV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobNotificationActionOperationsApi;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        String projectId = projectId_example; // String | 
        CreateNotificationActionRequest body = ; // CreateNotificationActionRequest | 
        try {
            apiInstance.createJobNotificationV2(projectId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#createJobNotificationV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
CreateNotificationActionRequest *body = ; //  (optional)

JobNotificationActionOperationsApi *apiInstance = [[JobNotificationActionOperationsApi alloc] init];

// Creates a new Job Notification Action.
[apiInstance createJobNotificationV2With:projectId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.JobNotificationActionOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'body':  // {{CreateNotificationActionRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createJobNotificationV2(projectId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createJobNotificationV2Example
    {
        public void main()
        {

            var apiInstance = new JobNotificationActionOperationsApi();
            var projectId = projectId_example;  // String | 
            var body = new CreateNotificationActionRequest(); // CreateNotificationActionRequest |  (optional) 

            try
            {
                // Creates a new Job Notification Action.
                apiInstance.createJobNotificationV2(projectId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobNotificationActionOperationsApi.createJobNotificationV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobNotificationActionOperationsApi();
$projectId = projectId_example; // String | 
$body = ; // CreateNotificationActionRequest | 

try {
    $api_instance->createJobNotificationV2($projectId, $body);
} catch (Exception $e) {
    echo 'Exception when calling JobNotificationActionOperationsApi->createJobNotificationV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobNotificationActionOperationsApi;

my $api_instance = WWW::SwaggerClient::JobNotificationActionOperationsApi->new();
my $projectId = projectId_example; # String | 
my $body = WWW::SwaggerClient::Object::CreateNotificationActionRequest->new(); # CreateNotificationActionRequest | 

eval { 
    $api_instance->createJobNotificationV2(projectId => $projectId, body => $body);
};
if ($@) {
    warn "Exception when calling JobNotificationActionOperationsApi->createJobNotificationV2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobNotificationActionOperationsApi()
projectId = projectId_example # String | 
body =  # CreateNotificationActionRequest |  (optional)

try: 
    # Creates a new Job Notification Action.
    api_instance.create_job_notification_v2(projectId, body=body)
except ApiException as e:
    print("Exception when calling JobNotificationActionOperationsApi->createJobNotificationV2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobNotificationActionOperationsApi;

import java.io.File;
import java.util.*;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.deleteJobNotificationV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#deleteJobNotificationV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobNotificationActionOperationsApi;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer id = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.deleteJobNotificationV2(id, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#deleteJobNotificationV2");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *projectId = projectId_example; // 

JobNotificationActionOperationsApi *apiInstance = [[JobNotificationActionOperationsApi alloc] init];

// Removes the given Job Notification Action.
[apiInstance deleteJobNotificationV2With:id
    projectId:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.JobNotificationActionOperationsApi()
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.deleteJobNotificationV2(id, projectId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteJobNotificationV2Example
    {
        public void main()
        {

            var apiInstance = new JobNotificationActionOperationsApi();
            var id = 56;  // Integer | 
            var projectId = projectId_example;  // String | 

            try
            {
                // Removes the given Job Notification Action.
                apiInstance.deleteJobNotificationV2(id, projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobNotificationActionOperationsApi.deleteJobNotificationV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobNotificationActionOperationsApi();
$id = 56; // Integer | 
$projectId = projectId_example; // String | 

try {
    $api_instance->deleteJobNotificationV2($id, $projectId);
} catch (Exception $e) {
    echo 'Exception when calling JobNotificationActionOperationsApi->deleteJobNotificationV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobNotificationActionOperationsApi;

my $api_instance = WWW::SwaggerClient::JobNotificationActionOperationsApi->new();
my $id = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->deleteJobNotificationV2(id => $id, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling JobNotificationActionOperationsApi->deleteJobNotificationV2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobNotificationActionOperationsApi()
id = 56 # Integer | 
projectId = projectId_example # String | 

try: 
    # Removes the given Job Notification Action.
    api_instance.delete_job_notification_v2(id, projectId)
except ApiException as e:
    print("Exception when calling JobNotificationActionOperationsApi->deleteJobNotificationV2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobNotificationActionOperationsApi;

import java.io.File;
import java.util.*;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer jobId = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.findAllJobNotificationByJobIdV2(jobId, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#findAllJobNotificationByJobIdV2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobNotificationActionOperationsApi;

public class JobNotificationActionOperationsApiExample {

    public static void main(String[] args) {
        JobNotificationActionOperationsApi apiInstance = new JobNotificationActionOperationsApi();
        Integer jobId = 56; // Integer | 
        String projectId = projectId_example; // String | 
        try {
            apiInstance.findAllJobNotificationByJobIdV2(jobId, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobNotificationActionOperationsApi#findAllJobNotificationByJobIdV2");
            e.printStackTrace();
        }
    }
}

Integer *jobId = 56; // 
String *projectId = projectId_example; // 

JobNotificationActionOperationsApi *apiInstance = [[JobNotificationActionOperationsApi alloc] init];

// Retrieves Job Notification Actions for the given job
[apiInstance findAllJobNotificationByJobIdV2With:jobId
    projectId:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SqlStreamBuilderApi = require('sql_stream_builder_api');

var api = new SqlStreamBuilderApi.JobNotificationActionOperationsApi()
var jobId = 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.findAllJobNotificationByJobIdV2(jobId, projectId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class findAllJobNotificationByJobIdV2Example
    {
        public void main()
        {

            var apiInstance = new JobNotificationActionOperationsApi();
            var jobId = 56;  // Integer | 
            var projectId = projectId_example;  // String | 

            try
            {
                // Retrieves Job Notification Actions for the given job
                apiInstance.findAllJobNotificationByJobIdV2(jobId, projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobNotificationActionOperationsApi.findAllJobNotificationByJobIdV2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobNotificationActionOperationsApi();
$jobId = 56; // Integer | 
$projectId = projectId_example; // String | 

try {
    $api_instance->findAllJobNotificationByJobIdV2($jobId, $projectId);
} catch (Exception $e) {
    echo 'Exception when calling JobNotificationActionOperationsApi->findAllJobNotificationByJobIdV2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobNotificationActionOperationsApi;

my $api_instance = WWW::SwaggerClient::JobNotificationActionOperationsApi->new();
my $jobId = 56; # Integer | 
my $projectId = projectId_example; # String | 

eval { 
    $api_instance->findAllJobNotificationByJobIdV2(jobId => $jobId, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling JobNotificationActionOperationsApi->findAllJobNotificationByJobIdV2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobNotificationActionOperationsApi()
jobId = 56 # Integer | 
projectId = projectId_example # String | 

try: 
    # Retrieves Job Notification Actions for the given job
    api_instance.find_all_job_notification_by_job_id_v2(jobId, projectId)
except ApiException as e:
    print("Exception when calling JobNotificationActionOperationsApi->findAllJobNotificationByJobIdV2: %s\n" % e)