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