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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.createApiKey(body, projectId, authorization);
            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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.createApiKey(body, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var body = ; // {{ApiKeySyncDto}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createApiKey(bodyprojectId, 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 | 
            var projectId = projectId_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a new api key in the specified project.
                ApiKeyDto result = apiInstance.createApiKey(body, projectId, authorization);
                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 | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createApiKey($body, $projectId, $authorization);
    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 | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createApiKey(body => $body, projectId => $projectId, authorization => $authorization);
    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 | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a new api key in the specified project.
    api_response = api_instance.create_api_key(body, projectId, authorization=authorization)
    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();
        ApiKeySyncDto body = ; // ApiKeySyncDto | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.createApiKey1(body, authorization);
            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();
        ApiKeySyncDto body = ; // ApiKeySyncDto | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.createApiKey1(body, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#createApiKey1");
            e.printStackTrace();
        }
    }
}

ApiKeySyncDto *body = ; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var body = ; // {{ApiKeySyncDto}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createApiKey1(body, 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 body = new ApiKeySyncDto(); // ApiKeySyncDto | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a new api key in the active project.
                ApiKeyDto result = apiInstance.createApiKey1(body, authorization);
                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();
$body = ; // ApiKeySyncDto | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createApiKey1($body, $authorization);
    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 $body = WWW::SwaggerClient::Object::ApiKeySyncDto->new(); # ApiKeySyncDto | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createApiKey1(body => $body, authorization => $authorization);
    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()
body =  # ApiKeySyncDto | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a new api key in the active project.
    api_response = api_instance.create_api_key1(body, authorization=authorization)
    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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteApiKeyById(id, projectId, authorization);
        } 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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteApiKeyById(id, projectId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var id = 56; // {{Integer}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteApiKeyById(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 deleteApiKeyByIdExample
    {
        public void main()
        {

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

            try
            {
                // Deletes an api key from the specified project.
                apiInstance.deleteApiKeyById(id, projectId, authorization);
            }
            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 | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteApiKeyById($id, $projectId, $authorization);
} 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 | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteApiKeyById(id => $id, projectId => $projectId, authorization => $authorization);
};
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 | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes an api key from the specified project.
    api_instance.delete_api_key_by_id(id, projectId, authorization=authorization)
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 authorization = authorization_example; // String | 
        try {
            apiInstance.deleteApiKeyById1(id, authorization);
        } 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 authorization = authorization_example; // String | 
        try {
            apiInstance.deleteApiKeyById1(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#deleteApiKeyById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteApiKeyById1(id, opts, 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 authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes an api key from the active project.
                apiInstance.deleteApiKeyById1(id, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteApiKeyById1($id, $authorization);
} 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 $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteApiKeyById1(id => $id, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes an api key from the active project.
    api_instance.delete_api_key_by_id1(id, authorization=authorization)
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();
        String authorization = authorization_example; // String | 
        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInActiveProject(authorization);
            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();
        String authorization = authorization_example; // String | 
        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInActiveProject(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getAllApiKeysInActiveProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllApiKeysInActiveProject(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all api keys in the active project.
                array[ApiKeyDto] result = apiInstance.getAllApiKeysInActiveProject(authorization);
                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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getAllApiKeysInActiveProject($authorization);
    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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getAllApiKeysInActiveProject(authorization => $authorization);
    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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all api keys in the active project.
    api_response = api_instance.get_all_api_keys_in_active_project(authorization=authorization)
    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 | 
        String authorization = authorization_example; // String | 
        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId, authorization);
            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 | 
        String authorization = authorization_example; // String | 
        try {
            array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getAllApiKeysInProject");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_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, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all api keys in the specified project.
                array[ApiKeyDto] result = apiInstance.getAllApiKeysInProject(projectId, authorization);
                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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getAllApiKeysInProject($projectId, $authorization);
    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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getAllApiKeysInProject(projectId => $projectId, authorization => $authorization);
    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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all api keys in the specified project.
    api_response = api_instance.get_all_api_keys_in_project(projectId, authorization=authorization)
    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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id, projectId, authorization);
            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 | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById(id, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var id = 56; // {{Integer}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getApiKeyById(id, projectId, opts, 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 | 
            var projectId = projectId_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves an api key from the specified project by its id.
                ApiKeyDto result = apiInstance.getApiKeyById(id, projectId, authorization);
                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 | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getApiKeyById($id, $projectId, $authorization);
    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 | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getApiKeyById(id => $id, projectId => $projectId, authorization => $authorization);
    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 | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves an api key from the specified project by its id.
    api_response = api_instance.get_api_key_by_id(id, projectId, authorization=authorization)
    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 authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById1(id, authorization);
            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 authorization = authorization_example; // String | 
        try {
            ApiKeyDto result = apiInstance.getApiKeyById1(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIKeyOperationsApi#getApiKeyById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.APIKeyOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_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, opts, 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 authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves an api key from the active project by its id.
                ApiKeyDto result = apiInstance.getApiKeyById1(id, authorization);
                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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getApiKeyById1($id, $authorization);
    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 $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getApiKeyById1(id => $id, authorization => $authorization);
    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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves an api key from the active project by its id.
    api_response = api_instance.get_api_key_by_id1(id, authorization=authorization)
    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();
        GenerateKeytabRequest body = ; // GenerateKeytabRequest | 
        String userId = userId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.generateKeytab2(body, userId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

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

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

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

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

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

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

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

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

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

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

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

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

eval { 
    $api_instance->generateKeytab2(body => $body, userId => $userId, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->generateKeytab2: $@\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()
body =  # GenerateKeytabRequest | 
userId = userId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Generates a keytab for the user with the given credentials.
    api_instance.generate_keytab2(body, userId, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->generateKeytab2: %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();
        GenerateKeytabRequest body = ; // GenerateKeytabRequest | 
        String userId = userId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.generateKeytab3(body, userId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#generateKeytab3");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

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

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

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

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

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

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

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

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

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

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

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

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

eval { 
    $api_instance->generateKeytab3(body => $body, userId => $userId, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->generateKeytab3: $@\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()
body =  # GenerateKeytabRequest | 
userId = userId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Generates a keytab for the user with the given credentials.
    api_instance.generate_keytab3(body, userId, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->generateKeytab3: %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();
        UpdatePasswordRequest body = ; // UpdatePasswordRequest | 
        String userId = userId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.updateUserPassword2(body, userId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

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

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

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

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

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

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

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

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

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

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

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

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

eval { 
    $api_instance->updateUserPassword2(body => $body, userId => $userId, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->updateUserPassword2: $@\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()
body =  # UpdatePasswordRequest | 
userId = userId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Updates the password for the user.
    api_instance.update_user_password2(body, userId, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->updateUserPassword2: %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();
        UpdatePasswordRequest body = ; // UpdatePasswordRequest | 
        String userId = userId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.updateUserPassword3(body, userId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#updateUserPassword3");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminOperationsApi;

public class AdminOperationsApiExample {

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

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

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

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

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

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

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

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

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

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

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

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

eval { 
    $api_instance->updateUserPassword3(body => $body, userId => $userId, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->updateUserPassword3: $@\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()
body =  # UpdatePasswordRequest | 
userId = userId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Updates the password for the user.
    api_instance.update_user_password3(body, userId, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->updateUserPassword3: %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 | 
        String principal = principal_example; // String | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.uploadKeytab2(userId, principal, file, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab2");
            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 | 
        String principal = principal_example; // String | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.uploadKeytab2(userId, principal, file, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab2");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // 
String *principal = principal_example; //  (optional)
byte[] *file = file_example; //  (optional)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.AdminOperationsApi()
var userId = userId_example; // {{String}} 
var opts = { 
  'principal': principal_example // {{String}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.uploadKeytab2(userId, opts, callback);

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

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

            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String | 
            var principal = principal_example;  // String |  (optional) 
            var file = file_example;  // byte[] |  (optional) 
            var authorization = authorization_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAdminOperationsApi();
$userId = userId_example; // String | 
$principal = principal_example; // String | 
$file = file_example; // byte[] | 
$authorization = authorization_example; // String | 

try {
    $api_instance->uploadKeytab2($userId, $principal, $file, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling AdminOperationsApi->uploadKeytab2: ', $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 $principal = principal_example; # String | 
my $file = file_example; # byte[] | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->uploadKeytab2(userId => $userId, principal => $principal, file => $file, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->uploadKeytab2: $@\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 | 
principal = principal_example # String |  (optional)
file = file_example # byte[] |  (optional)
authorization = authorization_example # String |  (optional)

try: 
    # Uploads a keytab file for the user with the given credentials.
    api_instance.upload_keytab2(userId, principal=principal, file=file, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->uploadKeytab2: %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 | 
        String principal = principal_example; // String | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.uploadKeytab3(userId, principal, file, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab3");
            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 | 
        String principal = principal_example; // String | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.uploadKeytab3(userId, principal, file, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminOperationsApi#uploadKeytab3");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // 
String *principal = principal_example; //  (optional)
byte[] *file = file_example; //  (optional)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.AdminOperationsApi()
var userId = userId_example; // {{String}} 
var opts = { 
  'principal': principal_example // {{String}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.uploadKeytab3(userId, opts, callback);

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

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

            var apiInstance = new AdminOperationsApi();
            var userId = userId_example;  // String | 
            var principal = principal_example;  // String |  (optional) 
            var file = file_example;  // byte[] |  (optional) 
            var authorization = authorization_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiAdminOperationsApi();
$userId = userId_example; // String | 
$principal = principal_example; // String | 
$file = file_example; // byte[] | 
$authorization = authorization_example; // String | 

try {
    $api_instance->uploadKeytab3($userId, $principal, $file, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling AdminOperationsApi->uploadKeytab3: ', $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 $principal = principal_example; # String | 
my $file = file_example; # byte[] | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->uploadKeytab3(userId => $userId, principal => $principal, file => $file, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling AdminOperationsApi->uploadKeytab3: $@\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 | 
principal = principal_example # String |  (optional)
file = file_example # byte[] |  (optional)
authorization = authorization_example # String |  (optional)

try: 
    # Uploads a keytab file for the user with the given credentials.
    api_instance.upload_keytab3(userId, principal=principal, file=file, authorization=authorization)
except ApiException as e:
    print("Exception when calling AdminOperationsApi->uploadKeytab3: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteArtifact(artifactName, scope, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteArtifact(artifactName, scope, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifact");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var artifactName = artifactName_example; // {{String}} 
var opts = { 
  'scope': scope_example, // {{String}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteArtifact(artifactName, 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 | 
            var scope = scope_example;  // String |  (optional) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Delete an artifact that is available to the user.
                apiInstance.deleteArtifact(artifactName, scope, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteArtifact($artifactName, $scope, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteArtifact(artifactName => $artifactName, scope => $scope, authorization => $authorization);
};
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 | 
scope = scope_example # String |  (optional)
authorization = authorization_example # String |  (optional)

try: 
    # Delete an artifact that is available to the user.
    api_instance.delete_artifact(artifactName, scope=scope, authorization=authorization)
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 name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteArtifactV2(name, scope, projectId, authorization);
        } 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 name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteArtifactV2(name, scope, projectId, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#deleteArtifactV2");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 
String *scope = scope_example; //  (optional) (default to USER)
String *projectId = projectId_example; // If scope is PROJECT, projectId has to be provided (optional)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var name = name_example; // {{String}} 
var opts = { 
  'scope': scope_example, // {{String}} 
  'projectId': projectId_example, // {{String}} If scope is PROJECT, projectId has to be provided
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteArtifactV2(name, opts, callback);

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

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

            var apiInstance = new ArtifactOperationsApi();
            var name = name_example;  // String | 
            var scope = scope_example;  // String |  (optional)  (default to USER)
            var projectId = projectId_example;  // String | If scope is PROJECT, projectId has to be provided (optional) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Delete an artifact that is available to the user.
                apiInstance.deleteArtifactV2(name, scope, projectId, authorization);
            }
            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();
$name = name_example; // String | 
$scope = scope_example; // String | 
$projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteArtifactV2($name, $scope, $projectId, $authorization);
} 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 $name = name_example; # String | 
my $scope = scope_example; # String | 
my $projectId = projectId_example; # String | If scope is PROJECT, projectId has to be provided
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteArtifactV2(name => $name, scope => $scope, projectId => $projectId, authorization => $authorization);
};
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()
name = name_example # String | 
scope = scope_example # String |  (optional) (default to USER)
projectId = projectId_example # String | If scope is PROJECT, projectId has to be provided (optional)
authorization = authorization_example # String |  (optional)

try: 
    # Delete an artifact that is available to the user.
    api_instance.delete_artifact_v2(name, scope=scope, projectId=projectId, authorization=authorization)
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 | 
        String authorization = authorization_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifact(artifactName, scope, authorization);
            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 | 
        String authorization = authorization_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifact(artifactName, scope, authorization);
            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)
String *authorization = authorization_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
    authorization:authorization
              completionHandler: ^(array[ArtifactDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var opts = { 
  'artifactName': artifactName_example, // {{String}} 
  'scope': scope_example, // {{String}} 
  'authorization': authorization_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) 
            var authorization = authorization_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, authorization);
                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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getArtifact($artifactName, $scope, $authorization);
    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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getArtifact(artifactName => $artifactName, scope => $scope, authorization => $authorization);
    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)
authorization = authorization_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, authorization=authorization)
    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 name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
        String authorization = authorization_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId, authorization);
            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 name = name_example; // String | 
        String scope = scope_example; // String | 
        String projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
        String authorization = authorization_example; // String | 
        try {
            array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ArtifactOperationsApi#getArtifactV2");
            e.printStackTrace();
        }
    }
}

String *name = name_example; //  (optional)
String *scope = scope_example; //  (optional) (default to USER)
String *projectId = projectId_example; // If scope is PROJECT, projectId has to be provided (optional)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var opts = { 
  'name': name_example, // {{String}} 
  'scope': scope_example, // {{String}} 
  'projectId': projectId_example, // {{String}} If scope is PROJECT, projectId has to be provided
  'authorization': authorization_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 name = name_example;  // String |  (optional) 
            var scope = scope_example;  // String |  (optional)  (default to USER)
            var projectId = projectId_example;  // String | If scope is PROJECT, projectId has to be provided (optional) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Lists artifacts available to the user. They can be filtered by scope or name.
                array[ArtifactDto] result = apiInstance.getArtifactV2(name, scope, projectId, authorization);
                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();
$name = name_example; // String | 
$scope = scope_example; // String | 
$projectId = projectId_example; // String | If scope is PROJECT, projectId has to be provided
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getArtifactV2($name, $scope, $projectId, $authorization);
    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 $name = name_example; # String | 
my $scope = scope_example; # String | 
my $projectId = projectId_example; # String | If scope is PROJECT, projectId has to be provided
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getArtifactV2(name => $name, scope => $scope, projectId => $projectId, authorization => $authorization);
    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()
name = name_example # String |  (optional)
scope = scope_example # String |  (optional) (default to USER)
projectId = projectId_example # String | If scope is PROJECT, projectId has to be provided (optional)
authorization = authorization_example # String |  (optional)

try: 
    # Lists artifacts available to the user. They can be filtered by scope or name.
    api_response = api_instance.get_artifact_v2(name=name, scope=scope, projectId=projectId, authorization=authorization)
    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 authorization = authorization_example; // String | 
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifact(file, authorization, 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 authorization = authorization_example; // String | 
        String artifactName = artifactName_example; // String | 
        String scope = scope_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifact(file, authorization, 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 *authorization = authorization_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
    authorization:authorization
    artifactName:artifactName
    scope:scope
              completionHandler: ^(ArtifactDto output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var opts = { 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
  '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 authorization = authorization_example;  // String |  (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, authorization, 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[] | 
$authorization = authorization_example; // String | 
$artifactName = artifactName_example; // String | 
$scope = scope_example; // String | 

try {
    $result = $api_instance->uploadArtifact($file, $authorization, $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 $authorization = authorization_example; # String | 
my $artifactName = artifactName_example; # String | 
my $scope = scope_example; # String | 

eval { 
    my $result = $api_instance->uploadArtifact(file => $file, authorization => $authorization, 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)
authorization = authorization_example # String |  (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, authorization=authorization, 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[] | 
        String authorization = authorization_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(data, file, authorization);
            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[] | 
        String authorization = authorization_example; // String | 
        try {
            ArtifactDto result = apiInstance.uploadArtifactV2(data, file, authorization);
            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)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ArtifactOperationsApi()
var opts = { 
  'data':  // {{UploadArtifactRequest}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
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) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Upload an artifact file.
                ArtifactDto result = apiInstance.uploadArtifactV2(data, file, authorization);
                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[] | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->uploadArtifactV2($data, $file, $authorization);
    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[] | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->uploadArtifactV2(data => $data, file => $file, authorization => $authorization);
    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)
authorization = authorization_example # String |  (optional)

try: 
    # Upload an artifact file.
    api_response = api_instance.upload_artifact_v2(data=data, file=file, authorization=authorization)
    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[] | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.createConnector(data, file, authorization);
            System.out.println(result);
        } 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[] | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.createConnector(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var opts = { 
  'data':  // {{ConnectorDto}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
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) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a Connector.
                ConnectorDto result = apiInstance.createConnector(data, file, authorization);
                Debug.WriteLine(result);
            }
            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[] | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createConnector($data, $file, $authorization);
    print_r($result);
} 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[] | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createConnector(data => $data, file => $file, authorization => $authorization);
    print Dumper($result);
};
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)
authorization = authorization_example # String |  (optional)

try: 
    # Creates a Connector.
    api_response = api_instance.create_connector(data=data, file=file, authorization=authorization)
    pprint(api_response)
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();
        ConnectorDto data = ; // ConnectorDto | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.createConnector1(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector1");
            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[] | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.createConnector1(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#createConnector1");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var opts = { 
  'data':  // {{ConnectorDto}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createConnector1(opts, callback);

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

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

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

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

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

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

try {
    $result = $api_instance->createConnector1($data, $file, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->createConnector1: ', $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[] | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createConnector1(data => $data, file => $file, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->createConnector1: $@\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)
authorization = authorization_example # String |  (optional)

try: 
    # Creates a Connector.
    api_response = api_instance.create_connector1(data=data, file=file, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->createConnector1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorById(id, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorById(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteConnectorById(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a Connector by ID.
                apiInstance.deleteConnectorById(id, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteConnectorById($id, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteConnectorById(id => $id, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Connector by ID.
    api_instance.delete_connector_by_id(id, authorization=authorization)
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();
        Integer id = 56; // Integer | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorById1(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorById1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorById1(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteConnectorById1(id, opts, callback);

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

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

            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer | 
            var authorization = authorization_example;  // String |  (optional) 

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

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

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

try {
    $api_instance->deleteConnectorById1($id, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->deleteConnectorById1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteConnectorById1(id => $id, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->deleteConnectorById1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Connector by ID.
    api_instance.delete_connector_by_id1(id, authorization=authorization)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->deleteConnectorById1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorByType(type, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorByType(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorByType");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteConnectorByType(type, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a Connector by type.
                apiInstance.deleteConnectorByType(type, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteConnectorByType($type, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteConnectorByType(type => $type, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Connector by type.
    api_instance.delete_connector_by_type(type, authorization=authorization)
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();
        String type = type_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorByType1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorByType1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteConnectorByType1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#deleteConnectorByType1");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteConnectorByType1(type, opts, callback);

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

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

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

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

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

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

try {
    $api_instance->deleteConnectorByType1($type, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->deleteConnectorByType1: ', $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 $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteConnectorByType1(type => $type, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->deleteConnectorByType1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Connector by type.
    api_instance.delete_connector_by_type1(type, authorization=authorization)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->deleteConnectorByType1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorById(id, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorById(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectorById(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a Connector by ID.
                ConnectorDto result = apiInstance.getConnectorById(id, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getConnectorById($id, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getConnectorById(id => $id, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by ID.
    api_response = api_instance.get_connector_by_id(id, authorization=authorization)
    pprint(api_response)
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();
        Integer id = 56; // Integer | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorById1(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorById1(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectorById1(id, opts, callback);

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

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

            var apiInstance = new ConnectorOperationsApi();
            var id = 56;  // Integer | 
            var authorization = authorization_example;  // String |  (optional) 

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

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

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

try {
    $result = $api_instance->getConnectorById1($id, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->getConnectorById1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getConnectorById1(id => $id, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorById1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by ID.
    api_response = api_instance.get_connector_by_id1(id, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorById1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorByType(type, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorByType(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorByType");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectorByType(type, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a Connector by type.
                ConnectorDto result = apiInstance.getConnectorByType(type, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getConnectorByType($type, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getConnectorByType(type => $type, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by type.
    api_response = api_instance.get_connector_by_type(type, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorByType1(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorByType1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            ConnectorDto result = apiInstance.getConnectorByType1(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorByType1");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectorByType1(type, opts, callback);

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

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

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

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

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

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

try {
    $result = $api_instance->getConnectorByType1($type, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->getConnectorByType1: ', $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 $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getConnectorByType1(type => $type, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorByType1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by type.
    api_response = api_instance.get_connector_by_type1(type, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorByType1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.getConnectorJarFile(type, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.getConnectorJarFile(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorJarFile");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
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 authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a Connector JAR file. Connector type must be specified.
                apiInstance.getConnectorJarFile(type, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->getConnectorJarFile($type, $authorization);
} 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 $authorization = authorization_example; # String | 

eval { 
    $api_instance->getConnectorJarFile(type => $type, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector JAR file. Connector type must be specified.
    api_instance.get_connector_jar_file(type, authorization=authorization)
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();
        String type = type_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.getConnectorJarFile1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorJarFile1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.getConnectorJarFile1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectorJarFile1");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConnectorJarFile1(type, opts, callback);

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

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

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

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

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

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

try {
    $api_instance->getConnectorJarFile1($type, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling ConnectorOperationsApi->getConnectorJarFile1: ', $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 $authorization = authorization_example; # String | 

eval { 
    $api_instance->getConnectorJarFile1(type => $type, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectorJarFile1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector JAR file. Connector type must be specified.
    api_instance.get_connector_jar_file1(type, authorization=authorization)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectorJarFile1: %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 authorization = authorization_example; // String | 
        try {
            array[ConnectorDto] result = apiInstance.getConnectors(authorization);
            System.out.println(result);
        } 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();
        String authorization = authorization_example; // String | 
        try {
            array[ConnectorDto] result = apiInstance.getConnectors(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectors");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectors(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all connectors.
                array[ConnectorDto] result = apiInstance.getConnectors(authorization);
                Debug.WriteLine(result);
            }
            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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getConnectors($authorization);
    print_r($result);
} 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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getConnectors(authorization => $authorization);
    print Dumper($result);
};
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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all connectors.
    api_response = api_instance.get_connectors(authorization=authorization)
    pprint(api_response)
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.ConnectorOperationsApi;

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

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            array[ConnectorDto] result = apiInstance.getConnectors1(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectors1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ConnectorOperationsApi;

public class ConnectorOperationsApiExample {

    public static void main(String[] args) {
        ConnectorOperationsApi apiInstance = new ConnectorOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            array[ConnectorDto] result = apiInstance.getConnectors1(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectorOperationsApi#getConnectors1");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.ConnectorOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnectors1(opts, callback);

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

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

            var apiInstance = new ConnectorOperationsApi();
            var authorization = authorization_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiConnectorOperationsApi();
$authorization = authorization_example; // String | 

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

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

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

eval { 
    my $result = $api_instance->getConnectors1(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectorOperationsApi->getConnectors1: $@\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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all connectors.
    api_response = api_instance.get_connectors1(authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorOperationsApi->getConnectors1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            GenerateCreateTableResponse result = apiInstance.createTable(body, authorization);
            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 | 
        String authorization = authorization_example; // String | 
        try {
            GenerateCreateTableResponse result = apiInstance.createTable(body, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DDLTemplatesApi#createTable");
            e.printStackTrace();
        }
    }
}

GenerateCreateTableRequest *body = ; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DDLTemplatesApi()
var body = ; // {{GenerateCreateTableRequest}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createTable(body, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                GenerateCreateTableResponse result = apiInstance.createTable(body, authorization);
                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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createTable($body, $authorization);
    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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createTable(body => $body, authorization => $authorization);
    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 | 
authorization = authorization_example # String |  (optional)

try: 
    api_response = api_instance.create_table(body, authorization=authorization)
    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[] | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.createDataFormat(data, file, authorization);
            System.out.println(result);
        } 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[] | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.createDataFormat(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var opts = { 
  'data':  // {{DataFormatDto}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
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) 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a Data Format.
                DataFormatDto result = apiInstance.createDataFormat(data, file, authorization);
                Debug.WriteLine(result);
            }
            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[] | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createDataFormat($data, $file, $authorization);
    print_r($result);
} 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[] | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createDataFormat(data => $data, file => $file, authorization => $authorization);
    print Dumper($result);
};
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)
authorization = authorization_example # String |  (optional)

try: 
    # Creates a Data Format.
    api_response = api_instance.create_data_format(data=data, file=file, authorization=authorization)
    pprint(api_response)
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();
        DataFormatDto data = ; // DataFormatDto | 
        byte[] file = file_example; // byte[] | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.createDataFormat1(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat1");
            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[] | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.createDataFormat1(data, file, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#createDataFormat1");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var opts = { 
  'data':  // {{DataFormatDto}} 
  'file': file_example // {{byte[]}} 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createDataFormat1(opts, callback);

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

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

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

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

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

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

try {
    $result = $api_instance->createDataFormat1($data, $file, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatOperationsApi->createDataFormat1: ', $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[] | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createDataFormat1(data => $data, file => $file, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->createDataFormat1: $@\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)
authorization = authorization_example # String |  (optional)

try: 
    # Creates a Data Format.
    api_response = api_instance.create_data_format1(data=data, file=file, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->createDataFormat1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatById(id, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatById(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteDataFormatById(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a Data Format by ID.
                apiInstance.deleteDataFormatById(id, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteDataFormatById($id, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataFormatById(id => $id, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Data Format by ID.
    api_instance.delete_data_format_by_id(id, authorization=authorization)
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();
        Integer id = 56; // Integer | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatById1(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatById1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatById1(id, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteDataFormatById1(id, opts, callback);

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

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

            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer | 
            var authorization = authorization_example;  // String |  (optional) 

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

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

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

try {
    $api_instance->deleteDataFormatById1($id, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatOperationsApi->deleteDataFormatById1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataFormatById1(id => $id, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->deleteDataFormatById1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Data Format by ID.
    api_instance.delete_data_format_by_id1(id, authorization=authorization)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->deleteDataFormatById1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatByType(type, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatByType(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatByType");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteDataFormatByType(type, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a Data Format by type.
                apiInstance.deleteDataFormatByType(type, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteDataFormatByType($type, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataFormatByType(type => $type, authorization => $authorization);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Data Format by type.
    api_instance.delete_data_format_by_type(type, authorization=authorization)
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();
        String type = type_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatByType1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatByType1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataFormatByType1(type, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#deleteDataFormatByType1");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteDataFormatByType1(type, opts, callback);

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

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

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

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

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

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

try {
    $api_instance->deleteDataFormatByType1($type, $authorization);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatOperationsApi->deleteDataFormatByType1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataFormatByType1(type => $type, authorization => $authorization);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->deleteDataFormatByType1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a Data Format by type.
    api_instance.delete_data_format_by_type1(type, authorization=authorization)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->deleteDataFormatByType1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatById(id, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatById(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormatById(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a Data Format by ID.
                DataFormatDto result = apiInstance.getDataFormatById(id, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataFormatById($id, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataFormatById(id => $id, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Data Format by ID.
    api_response = api_instance.get_data_format_by_id(id, authorization=authorization)
    pprint(api_response)
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();
        Integer id = 56; // Integer | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatById1(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatById1(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatById1");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var id = 56; // {{Integer}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormatById1(id, opts, callback);

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

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

            var apiInstance = new DataFormatOperationsApi();
            var id = 56;  // Integer | 
            var authorization = authorization_example;  // String |  (optional) 

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

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

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

try {
    $result = $api_instance->getDataFormatById1($id, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatOperationsApi->getDataFormatById1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataFormatById1(id => $id, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatById1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Data Format by ID.
    api_response = api_instance.get_data_format_by_id1(id, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormatById1: %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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatByType(type, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatByType(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatByType");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormatByType(type, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a Connector by type.
                DataFormatDto result = apiInstance.getDataFormatByType(type, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataFormatByType($type, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataFormatByType(type => $type, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by type.
    api_response = api_instance.get_data_format_by_type(type, authorization=authorization)
    pprint(api_response)
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();
        String type = type_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatByType1(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatByType1");
            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 | 
        String authorization = authorization_example; // String | 
        try {
            DataFormatDto result = apiInstance.getDataFormatByType1(type, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormatByType1");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var type = type_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormatByType1(type, opts, callback);

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

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

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

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

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

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

try {
    $result = $api_instance->getDataFormatByType1($type, $authorization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatOperationsApi->getDataFormatByType1: ', $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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataFormatByType1(type => $type, authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormatByType1: $@\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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a Connector by type.
    api_response = api_instance.get_data_format_by_type1(type, authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormatByType1: %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 authorization = authorization_example; // String | 
        try {
            array[DataFormatDto] result = apiInstance.getDataFormats(authorization);
            System.out.println(result);
        } 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();
        String authorization = authorization_example; // String | 
        try {
            array[DataFormatDto] result = apiInstance.getDataFormats(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormats");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormats(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all Data Formats.
                array[DataFormatDto] result = apiInstance.getDataFormats(authorization);
                Debug.WriteLine(result);
            }
            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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataFormats($authorization);
    print_r($result);
} 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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataFormats(authorization => $authorization);
    print Dumper($result);
};
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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all Data Formats.
    api_response = api_instance.get_data_formats(authorization=authorization)
    pprint(api_response)
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.DataFormatOperationsApi;

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

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            array[DataFormatDto] result = apiInstance.getDataFormats1(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormats1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DataFormatOperationsApi;

public class DataFormatOperationsApiExample {

    public static void main(String[] args) {
        DataFormatOperationsApi apiInstance = new DataFormatOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            array[DataFormatDto] result = apiInstance.getDataFormats1(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatOperationsApi#getDataFormats1");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataFormatOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataFormats1(opts, callback);

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

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

            var apiInstance = new DataFormatOperationsApi();
            var authorization = authorization_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDataFormatOperationsApi();
$authorization = authorization_example; // String | 

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

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

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

eval { 
    my $result = $api_instance->getDataFormats1(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatOperationsApi->getDataFormats1: $@\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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all Data Formats.
    api_response = api_instance.get_data_formats1(authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatOperationsApi->getDataFormats1: %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 authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.copyDataSource(id, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.copyDataSource(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSource");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.copyDataSource(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a copy of a data source in the active project.
                DataSourceDto result = apiInstance.copyDataSource(id, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->copyDataSource($id, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->copyDataSource(id => $id, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a copy of a data source in the active project.
    api_response = api_instance.copy_data_source(id, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#copyDataSourceV2");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.copyDataSourceV2(id, projectId, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a copy of a data source in the specified project.
                DataSourceDto result = apiInstance.copyDataSourceV2(id, projectId, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->copyDataSourceV2($id, $projectId, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->copyDataSourceV2(id => $id, projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a copy of a data source in the specified project.
    api_response = api_instance.copy_data_source_v2(id, projectId, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.createDataSource(body, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.createDataSource(body, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSource");
            e.printStackTrace();
        }
    }
}

DataSourceDto *body = ; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceDto}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createDataSource(body, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a data source in the active project.
                DataSourceDto result = apiInstance.createDataSource(body, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createDataSource($body, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createDataSource(body => $body, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a data source in the active project.
    api_response = api_instance.create_data_source(body, authorization=authorization)
    pprint(api_response)
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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.createDataSourceV2(body, projectId, authorization);
            System.out.println(result);
        } 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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.createDataSourceV2(body, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#createDataSourceV2");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceSyncDto}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createDataSourceV2(bodyprojectId, 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 body = new DataSourceSyncDto(); // DataSourceSyncDto | 
            var projectId = projectId_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Creates a data source in the specified project.
                DataSourceDto result = apiInstance.createDataSourceV2(body, projectId, authorization);
                Debug.WriteLine(result);
            }
            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();
$body = ; // DataSourceSyncDto | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->createDataSourceV2($body, $projectId, $authorization);
    print_r($result);
} 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 $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->createDataSourceV2(body => $body, projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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()
body =  # DataSourceSyncDto | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Creates a data source in the specified project.
    api_response = api_instance.create_data_source_v2(body, projectId, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataSource(id, deleteDependents, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataSource(id, deleteDependents, authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#deleteDataSource");
            e.printStackTrace();
        }
    }
}

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

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var opts = { 
  'deleteDependents': true, // {{Boolean}} 
  'authorization': authorization_example // {{String}} 
};
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)
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a data source from the active project.
                apiInstance.deleteDataSource(id, deleteDependents, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteDataSource($id, $deleteDependents, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataSource(id => $id, deleteDependents => $deleteDependents, authorization => $authorization);
};
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)
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a data source from the active project.
    api_instance.delete_data_source(id, deleteDependents=deleteDependents, authorization=authorization)
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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataSourceV2(id, projectId, deleteDependents, authorization);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            apiInstance.deleteDataSourceV2(id, projectId, deleteDependents, authorization);
        } 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)
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'deleteDependents': true, // {{Boolean}} 
  'authorization': authorization_example // {{String}} 
};
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)
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Deletes a data source from the specified project.
                apiInstance.deleteDataSourceV2(id, projectId, deleteDependents, authorization);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $api_instance->deleteDataSourceV2($id, $projectId, $deleteDependents, $authorization);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    $api_instance->deleteDataSourceV2(id => $id, projectId => $projectId, deleteDependents => $deleteDependents, authorization => $authorization);
};
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)
authorization = authorization_example # String |  (optional)

try: 
    # Deletes a data source from the specified project.
    api_instance.delete_data_source_v2(id, projectId, deleteDependents=deleteDependents, authorization=authorization)
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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectById(id, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectById(id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectById");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataSourceInProjectById(id, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a data source in the active project by its id.
                DataSourceDto result = apiInstance.getDataSourceInProjectById(id, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataSourceInProjectById($id, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataSourceInProjectById(id => $id, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a data source in the active project by its id.
    api_response = api_instance.get_data_source_in_project_by_id(id, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourceInProjectByIdV2");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // 
String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var id = id_example; // {{String}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataSourceInProjectByIdV2(id, projectId, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves a data source in the specified project by its id.
                DataSourceDto result = apiInstance.getDataSourceInProjectByIdV2(id, projectId, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataSourceInProjectByIdV2($id, $projectId, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataSourceInProjectByIdV2(id => $id, projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves a data source in the specified project by its id.
    api_response = api_instance.get_data_source_in_project_by_id_v2(id, projectId, authorization=authorization)
    pprint(api_response)
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();
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProject(authorization);
            System.out.println(result);
        } 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();
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProject(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourcesInProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataSourcesInProject(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all data sources in the active project.
                array[DataSourceDto] result = apiInstance.getDataSourcesInProject(authorization);
                Debug.WriteLine(result);
            }
            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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataSourcesInProject($authorization);
    print_r($result);
} 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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataSourcesInProject(authorization => $authorization);
    print Dumper($result);
};
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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all data sources in the active project.
    api_response = api_instance.get_data_sources_in_project(authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getDataSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataSourcesInProjectV2(projectId, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves all data sources in the specified project.
                array[DataSourceDto] result = apiInstance.getDataSourcesInProjectV2(projectId, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getDataSourcesInProjectV2($projectId, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getDataSourcesInProjectV2(projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves all data sources in the specified project.
    api_response = api_instance.get_data_sources_in_project_v2(projectId, authorization=authorization)
    pprint(api_response)
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();
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProject(authorization);
            System.out.println(result);
        } 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();
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProject(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getKafkaSourcesInProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getKafkaSourcesInProject(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves Kafka data sources in the active project.
                array[DataSourceDto] result = apiInstance.getKafkaSourcesInProject(authorization);
                Debug.WriteLine(result);
            }
            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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getKafkaSourcesInProject($authorization);
    print_r($result);
} 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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getKafkaSourcesInProject(authorization => $authorization);
    print Dumper($result);
};
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()
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves Kafka data sources in the active project.
    api_response = api_instance.get_kafka_sources_in_project(authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#getKafkaSourcesInProjectV2");
            e.printStackTrace();
        }
    }
}

String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getKafkaSourcesInProjectV2(projectId, opts, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Retrieves Kafka data sources in the specified project.
                array[DataSourceDto] result = apiInstance.getKafkaSourcesInProjectV2(projectId, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->getKafkaSourcesInProjectV2($projectId, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getKafkaSourcesInProjectV2(projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Retrieves Kafka data sources in the specified project.
    api_response = api_instance.get_kafka_sources_in_project_v2(projectId, authorization=authorization)
    pprint(api_response)
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();
        DataSourceDto body = ; // DataSourceDto | 
        String id = id_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.updateDataSource(body, id, authorization);
            System.out.println(result);
        } 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();
        DataSourceDto body = ; // DataSourceDto | 
        String id = id_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.updateDataSource(body, id, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSource");
            e.printStackTrace();
        }
    }
}

DataSourceDto *body = ; // 
String *id = id_example; // 
String *authorization = authorization_example; //  (optional)

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

// Updates an existing data source in the active project.
[apiInstance updateDataSourceWith:body
    id:id
    authorization:authorization
              completionHandler: ^(DataSourceDto output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceDto}} 
var id = id_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateDataSource(bodyid, 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 body = new DataSourceDto(); // DataSourceDto | 
            var id = id_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Updates an existing data source in the active project.
                DataSourceDto result = apiInstance.updateDataSource(body, id, authorization);
                Debug.WriteLine(result);
            }
            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();
$body = ; // DataSourceDto | 
$id = id_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->updateDataSource($body, $id, $authorization);
    print_r($result);
} 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 $body = WWW::SwaggerClient::Object::DataSourceDto->new(); # DataSourceDto | 
my $id = id_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->updateDataSource(body => $body, id => $id, authorization => $authorization);
    print Dumper($result);
};
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()
body =  # DataSourceDto | 
id = id_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Updates an existing data source in the active project.
    api_response = api_instance.update_data_source(body, id, authorization=authorization)
    pprint(api_response)
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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.updateDataSourceV2(body, id, projectId, authorization);
            System.out.println(result);
        } 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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String id = id_example; // String | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            DataSourceDto result = apiInstance.updateDataSourceV2(body, id, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#updateDataSourceV2");
            e.printStackTrace();
        }
    }
}

DataSourceSyncDto *body = ; // 
String *id = id_example; // 
String *projectId = projectId_example; // 
String *authorization = authorization_example; //  (optional)

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

// Updates an existing data source in the specified project.
[apiInstance updateDataSourceV2With:body
    id:id
    projectId:projectId
    authorization:authorization
              completionHandler: ^(DataSourceDto output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceSyncDto}} 
var id = id_example; // {{String}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateDataSourceV2(bodyidprojectId, 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 body = new DataSourceSyncDto(); // DataSourceSyncDto | 
            var id = id_example;  // String | 
            var projectId = projectId_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Updates an existing data source in the specified project.
                DataSourceDto result = apiInstance.updateDataSourceV2(body, id, projectId, authorization);
                Debug.WriteLine(result);
            }
            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();
$body = ; // DataSourceSyncDto | 
$id = id_example; // String | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->updateDataSourceV2($body, $id, $projectId, $authorization);
    print_r($result);
} 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 $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 
my $id = id_example; # String | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->updateDataSourceV2(body => $body, id => $id, projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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()
body =  # DataSourceSyncDto | 
id = id_example # String | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Updates an existing data source in the specified project.
    api_response = api_instance.update_data_source_v2(body, id, projectId, authorization=authorization)
    pprint(api_response)
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 | 
        String authorization = authorization_example; // String | 
        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSource(body, authorization);
            System.out.println(result);
        } 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 | 
        String authorization = authorization_example; // String | 
        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSource(body, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSource");
            e.printStackTrace();
        }
    }
}

DataSourceDto *body = ; // 
String *authorization = authorization_example; //  (optional)

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

// Validates a data source as a Flink catalog in the active project.
[apiInstance validateDataSourceWith:body
    authorization:authorization
              completionHandler: ^(ValidateDataSourceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceDto}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.validateDataSource(body, 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 | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Validates a data source as a Flink catalog in the active project.
                ValidateDataSourceResponse result = apiInstance.validateDataSource(body, authorization);
                Debug.WriteLine(result);
            }
            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 | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->validateDataSource($body, $authorization);
    print_r($result);
} 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 | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->validateDataSource(body => $body, authorization => $authorization);
    print Dumper($result);
};
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 | 
authorization = authorization_example # String |  (optional)

try: 
    # Validates a data source as a Flink catalog in the active project.
    api_response = api_instance.validate_data_source(body, authorization=authorization)
    pprint(api_response)
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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(body, projectId, authorization);
            System.out.println(result);
        } 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();
        DataSourceSyncDto body = ; // DataSourceSyncDto | 
        String projectId = projectId_example; // String | 
        String authorization = authorization_example; // String | 
        try {
            ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(body, projectId, authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceOperationsApi#validateDataSourceV2");
            e.printStackTrace();
        }
    }
}

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

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

// Validates a data source as a Flink catalog in the active project.
[apiInstance validateDataSourceV2With:body
    projectId:projectId
    authorization:authorization
              completionHandler: ^(ValidateDataSourceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DataSourceOperationsApi()
var body = ; // {{DataSourceSyncDto}} 
var projectId = projectId_example; // {{String}} 
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.validateDataSourceV2(bodyprojectId, 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 body = new DataSourceSyncDto(); // DataSourceSyncDto | 
            var projectId = projectId_example;  // String | 
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                // Validates a data source as a Flink catalog in the active project.
                ValidateDataSourceResponse result = apiInstance.validateDataSourceV2(body, projectId, authorization);
                Debug.WriteLine(result);
            }
            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();
$body = ; // DataSourceSyncDto | 
$projectId = projectId_example; // String | 
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->validateDataSourceV2($body, $projectId, $authorization);
    print_r($result);
} 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 $body = WWW::SwaggerClient::Object::DataSourceSyncDto->new(); # DataSourceSyncDto | 
my $projectId = projectId_example; # String | 
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->validateDataSourceV2(body => $body, projectId => $projectId, authorization => $authorization);
    print Dumper($result);
};
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()
body =  # DataSourceSyncDto | 
projectId = projectId_example # String | 
authorization = authorization_example # String |  (optional)

try: 
    # Validates a data source as a Flink catalog in the active project.
    api_response = api_instance.validate_data_source_v2(body, projectId, authorization=authorization)
    pprint(api_response)
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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseConnectStringResponse result = apiInstance.connectString(authorization);
            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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseConnectStringResponse result = apiInstance.connectString(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#connectString");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

[apiInstance connectStringWith:authorization
              completionHandler: ^(DatabaseConnectStringResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DatabaseInfoApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectString(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                DatabaseConnectStringResponse result = apiInstance.connectString(authorization);
                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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->connectString($authorization);
    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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->connectString(authorization => $authorization);
    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()
authorization = authorization_example # String |  (optional)

try: 
    api_response = api_instance.connect_string(authorization=authorization)
    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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseInfoResponse result = apiInstance.info(authorization);
            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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseInfoResponse result = apiInstance.info(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#info");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

[apiInstance infoWith:authorization
              completionHandler: ^(DatabaseInfoResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DatabaseInfoApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.info(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                DatabaseInfoResponse result = apiInstance.info(authorization);
                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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->info($authorization);
    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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->info(authorization => $authorization);
    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()
authorization = authorization_example # String |  (optional)

try: 
    api_response = api_instance.info(authorization=authorization)
    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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseVersionResponse result = apiInstance.version(authorization);
            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();
        String authorization = authorization_example; // String | 
        try {
            DatabaseVersionResponse result = apiInstance.version(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseInfoApi#version");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

[apiInstance versionWith:authorization
              completionHandler: ^(DatabaseVersionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DatabaseInfoApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.version(opts, 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();
            var authorization = authorization_example;  // String |  (optional) 

            try
            {
                DatabaseVersionResponse result = apiInstance.version(authorization);
                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();
$authorization = authorization_example; // String | 

try {
    $result = $api_instance->version($authorization);
    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();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->version(authorization => $authorization);
    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()
authorization = authorization_example # String |  (optional)

try: 
    api_response = api_instance.version(authorization=authorization)
    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.DiagnosticOperationsApi;

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

public class DiagnosticOperationsApiExample {

    public static void main(String[] args) {
        
        DiagnosticOperationsApi apiInstance = new DiagnosticOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            CountersResponse result = apiInstance.getCounters(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiagnosticOperationsApi#getCounters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiagnosticOperationsApi;

public class DiagnosticOperationsApiExample {

    public static void main(String[] args) {
        DiagnosticOperationsApi apiInstance = new DiagnosticOperationsApi();
        String authorization = authorization_example; // String | 
        try {
            CountersResponse result = apiInstance.getCounters(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiagnosticOperationsApi#getCounters");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; //  (optional)

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

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

var StreamingSqlEngineApi = require('streaming_sql_engine_api');

var api = new StreamingSqlEngineApi.DiagnosticOperationsApi()
var opts = { 
  'authorization': authorization_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCounters(opts, callback);

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

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

            var apiInstance = new DiagnosticOperationsApi();
            var authorization = authorization_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiagnosticOperationsApi();
$authorization = authorization_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::DiagnosticOperationsApi->new();
my $authorization = authorization_example; # String | 

eval { 
    my $result = $api_instance->getCounters(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiagnosticOperationsApi->getCounters: $@\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.DiagnosticOperationsApi()
authorization = authorization_example # String |  (optional)

try: 
    api_response = api_instance.get_counters(authorization=authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiagnosticOperationsApi->getCounters: %s\n" % e)