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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to do bulk loading.
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createDataloadingJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to do bulk loading.
final SchemaMapping schemaMapping = new SchemaMapping(); // SchemaMapping | 

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to do bulk loading.
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createDataloadingJob");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to do bulk loading. (default to null)
SchemaMapping *schemaMapping = ; // 

[apiInstance createDataloadingJobWith:graphId
    schemaMapping:schemaMapping
              completionHandler: ^(JobResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to do bulk loading.
var schemaMapping = ; // {SchemaMapping} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to do bulk loading. (default to null)
            var schemaMapping = new SchemaMapping(); // SchemaMapping | 

            try {
                JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createDataloadingJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to do bulk loading.
$schemaMapping = ; // SchemaMapping | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to do bulk loading.
my $schemaMapping = WWW::OPenAPIClient::Object::SchemaMapping->new(); # SchemaMapping | 

eval {
    my $result = $api_instance->createDataloadingJob(graphId => $graphId, schemaMapping => $schemaMapping);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createDataloadingJob: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to do bulk loading. (default to null)
schemaMapping =  # SchemaMapping | 

try:
    api_response = api_instance.create_dataloading_job(graphId, schemaMapping)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createDataloadingJob: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let schemaMapping = ; // SchemaMapping

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createDataloadingJob(graphId, schemaMapping, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

        try {
            CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateGraphRequest createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

        try {
            CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createGraph");
            e.printStackTrace();
        }
    }
}

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

[apiInstance createGraphWith:createGraphRequest
              completionHandler: ^(CreateGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var createGraphRequest = ; // {CreateGraphRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

            try {
                CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$createGraphRequest = ; // CreateGraphRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $createGraphRequest = WWW::OPenAPIClient::Object::CreateGraphRequest->new(); # CreateGraphRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
createGraphRequest =  # CreateGraphRequest | 

try:
    api_response = api_instance.create_graph(createGraphRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let createGraphRequest = ; // CreateGraphRequest

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createGraph(createGraphRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            'String' result = apiInstance.deleteGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to delete

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            'String' result = apiInstance.deleteGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteGraph");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to delete (default to null)

[apiInstance deleteGraphWith:graphId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to delete

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to delete (default to null)

            try {
                'String' result = apiInstance.deleteGraph(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to delete

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to delete

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to delete (default to null)

try:
    api_response = api_instance.delete_graph(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->deleteGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteGraph(graphId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get

        try {
            GetGraphResponse result = apiInstance.getGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to get

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get

        try {
            GetGraphResponse result = apiInstance.getGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraph");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to get (default to null)

[apiInstance getGraphWith:graphId
              completionHandler: ^(GetGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to get

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to get (default to null)

            try {
                GetGraphResponse result = apiInstance.getGraph(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to get

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to get

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to get (default to null)

try:
    api_response = api_instance.get_graph(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getGraph(graphId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get statistics

        try {
            GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraphStatistic");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to get statistics

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get statistics

        try {
            GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraphStatistic");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to get statistics (default to null)

[apiInstance getGraphStatisticWith:graphId
              completionHandler: ^(GetGraphStatisticsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to get statistics

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to get statistics (default to null)

            try {
                GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getGraphStatistic: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to get statistics

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to get statistics

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to get statistics (default to null)

try:
    api_response = api_instance.get_graph_statistic(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getGraphStatistic: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getGraphStatistic(graphId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSchema");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to delete

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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSchema");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to delete (default to null)

[apiInstance getSchemaWith:graphId
              completionHandler: ^(GetGraphSchemaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to delete

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to delete (default to null)

            try {
                GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to delete

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to delete

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to delete (default to null)

try:
    api_response = api_instance.get_schema(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getSchema: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getSchema(graphId, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminServiceGraphManagementApi;

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

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

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

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

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

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

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

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

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

            try {
                array[GetGraphResponse] result = apiInstance.listGraphs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.listGraphs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AdminServiceGraphManagementApi;

pub fn main() {

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.listGraphs(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | 

        try {
            'String' result = apiInstance.deleteJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#deleteJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdminServiceJobManagementApi;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | 

        try {
            'String' result = apiInstance.deleteJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#deleteJobById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceJobManagementApi *apiInstance = [[AdminServiceJobManagementApi alloc] init];
String *jobId = jobId_example; //  (default to null)

[apiInstance deleteJobByIdWith:jobId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceJobManagementApi()
var jobId = jobId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceJobManagementApi();
            var jobId = jobId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteJobById(jobId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.deleteJobById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceJobManagementApi();
$jobId = jobId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceJobManagementApi->new();
my $jobId = jobId_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceJobManagementApi()
jobId = jobId_example # String |  (default to null)

try:
    api_response = api_instance.delete_job_by_id(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceJobManagementApi->deleteJobById: %s\n" % e)

extern crate AdminServiceJobManagementApi;

pub fn main() {
    let jobId = jobId_example; // String

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.deleteJobById(jobId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#getJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

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

import org.openapitools.client.api.AdminServiceJobManagementApi;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#getJobById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceJobManagementApi *apiInstance = [[AdminServiceJobManagementApi alloc] init];
String *jobId = jobId_example; // The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

[apiInstance getJobByIdWith:jobId
              completionHandler: ^(JobStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceJobManagementApi()
var jobId = jobId_example; // {String} The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceJobManagementApi();
            var jobId = jobId_example;  // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

            try {
                JobStatus result = apiInstance.getJobById(jobId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.getJobById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceJobManagementApi();
$jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceJobManagementApi->new();
my $jobId = jobId_example; # String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceJobManagementApi()
jobId = jobId_example # String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

try:
    api_response = api_instance.get_job_by_id(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceJobManagementApi->getJobById: %s\n" % e)

extern crate AdminServiceJobManagementApi;

pub fn main() {
    let jobId = jobId_example; // String

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.getJobById(jobId, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminServiceJobManagementApi;

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

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

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

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

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

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

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

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

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

            try {
                array[JobStatus] result = apiInstance.listJobs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.listJobs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AdminServiceJobManagementApi;

pub fn main() {

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.listJobs(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        CreateProcedureRequest createProcedureRequest = ; // CreateProcedureRequest | 

        try {
            CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#createProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateProcedureRequest createProcedureRequest = new CreateProcedureRequest(); // CreateProcedureRequest | 

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

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        CreateProcedureRequest createProcedureRequest = ; // CreateProcedureRequest | 

        try {
            CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#createProcedure");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateProcedureRequest *createProcedureRequest = ; // 

[apiInstance createProcedureWith:graphId
    createProcedureRequest:createProcedureRequest
              completionHandler: ^(CreateProcedureResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var createProcedureRequest = ; // {CreateProcedureRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createProcedureRequest = new CreateProcedureRequest(); // CreateProcedureRequest | 

            try {
                CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.createProcedure: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$createProcedureRequest = ; // CreateProcedureRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $createProcedureRequest = WWW::OPenAPIClient::Object::CreateProcedureRequest->new(); # CreateProcedureRequest | 

eval {
    my $result = $api_instance->createProcedure(graphId => $graphId, createProcedureRequest => $createProcedureRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->createProcedure: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
createProcedureRequest =  # CreateProcedureRequest | 

try:
    api_response = api_instance.create_procedure(graphId, createProcedureRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->createProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createProcedureRequest = ; // CreateProcedureRequest

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.createProcedure(graphId, createProcedureRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#deleteProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 

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

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#deleteProcedure");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)

[apiInstance deleteProcedureWith:graphId
    procedureId:procedureId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteProcedure(graphId, procedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.deleteProcedure: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 

eval {
    my $result = $api_instance->deleteProcedure(graphId => $graphId, procedureId => $procedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->deleteProcedure: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)

try:
    api_response = api_instance.delete_procedure(graphId, procedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->deleteProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.deleteProcedure(graphId, procedureId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#getProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 

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

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#getProcedure");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)

[apiInstance getProcedureWith:graphId
    procedureId:procedureId
              completionHandler: ^(GetProcedureResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)

            try {
                GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.getProcedure: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 

eval {
    my $result = $api_instance->getProcedure(graphId => $graphId, procedureId => $procedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->getProcedure: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)

try:
    api_response = api_instance.get_procedure(graphId, procedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->getProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.getProcedure(graphId, procedureId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#listProcedures");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#listProcedures");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance listProceduresWith:graphId
              completionHandler: ^(array[GetProcedureResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.listProcedures: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.list_procedures(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->listProcedures: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.listProcedures(graphId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 
        UpdateProcedureRequest updateProcedureRequest = ; // UpdateProcedureRequest | 

        try {
            'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#updateProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 
final UpdateProcedureRequest updateProcedureRequest = new UpdateProcedureRequest(); // UpdateProcedureRequest | 

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

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 
        UpdateProcedureRequest updateProcedureRequest = ; // UpdateProcedureRequest | 

        try {
            'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#updateProcedure");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)
UpdateProcedureRequest *updateProcedureRequest = ; //  (optional)

[apiInstance updateProcedureWith:graphId
    procedureId:procedureId
    updateProcedureRequest:updateProcedureRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 
var opts = {
  'updateProcedureRequest':  // {UpdateProcedureRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)
            var updateProcedureRequest = new UpdateProcedureRequest(); // UpdateProcedureRequest |  (optional) 

            try {
                'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.updateProcedure: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 
$updateProcedureRequest = ; // UpdateProcedureRequest | 

try {
    $result = $api_instance->updateProcedure($graphId, $procedureId, $updateProcedureRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->updateProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 
my $updateProcedureRequest = WWW::OPenAPIClient::Object::UpdateProcedureRequest->new(); # UpdateProcedureRequest | 

eval {
    my $result = $api_instance->updateProcedure(graphId => $graphId, procedureId => $procedureId, updateProcedureRequest => $updateProcedureRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->updateProcedure: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)
updateProcedureRequest =  # UpdateProcedureRequest |  (optional)

try:
    api_response = api_instance.update_procedure(graphId, procedureId, updateProcedureRequest=updateProcedureRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->updateProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String
    let updateProcedureRequest = ; // UpdateProcedureRequest

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.updateProcedure(graphId, procedureId, updateProcedureRequest, &context).wait();

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

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

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

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

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

        try {
            ServiceStatus result = apiInstance.getServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#getServiceStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminServiceServiceManagementApi;

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

        try {
            ServiceStatus result = apiInstance.getServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#getServiceStatus");
            e.printStackTrace();
        }
    }
}

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

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

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

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

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

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

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

            try {
                ServiceStatus result = apiInstance.getServiceStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.getServiceStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.getServiceStatus(&context).wait();

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

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

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

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

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

        try {
            'String' result = apiInstance.restartService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#restartService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminServiceServiceManagementApi;

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

        try {
            'String' result = apiInstance.restartService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#restartService");
            e.printStackTrace();
        }
    }
}

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

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

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

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

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

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

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

            try {
                'String' result = apiInstance.restartService();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.restartService: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.restartService(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

        try {
            'String' result = apiInstance.startService(startServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#startService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StartServiceRequest startServiceRequest = new StartServiceRequest(); // StartServiceRequest | 

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

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

        try {
            'String' result = apiInstance.startService(startServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#startService");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];
StartServiceRequest *startServiceRequest = ; //  (optional)

[apiInstance startServiceWith:startServiceRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var opts = {
  'startServiceRequest':  // {StartServiceRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();
            var startServiceRequest = new StartServiceRequest(); // StartServiceRequest |  (optional) 

            try {
                'String' result = apiInstance.startService(startServiceRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.startService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();
$startServiceRequest = ; // StartServiceRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();
my $startServiceRequest = WWW::OPenAPIClient::Object::StartServiceRequest->new(); # StartServiceRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()
startServiceRequest =  # StartServiceRequest |  (optional)

try:
    api_response = api_instance.start_service(startServiceRequest=startServiceRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->startService: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {
    let startServiceRequest = ; // StartServiceRequest

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.startService(startServiceRequest, &context).wait();

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

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

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

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

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

        try {
            'String' result = apiInstance.stopService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#stopService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminServiceServiceManagementApi;

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

        try {
            'String' result = apiInstance.stopService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#stopService");
            e.printStackTrace();
        }
    }
}

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

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

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

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

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

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

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

            try {
                'String' result = apiInstance.stopService();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.stopService: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.stopService(&context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.addEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#addEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final array[EdgeRequest] edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

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

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.addEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#addEdge");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
array[EdgeRequest] *edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // 

// Add edge to the graph
[apiInstance addEdgeWith:graphId
    edgeRequest:edgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // {array[EdgeRequest]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

            try {
                // Add edge to the graph
                'String' result = apiInstance.addEdge(graphId, edgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.addEdge: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeRequest = [WWW::OPenAPIClient::Object::array[EdgeRequest]->new()]; # array[EdgeRequest] | 

eval {
    my $result = $api_instance->addEdge(graphId => $graphId, edgeRequest => $edgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->addEdge: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}] # array[EdgeRequest] | 

try:
    # Add edge to the graph
    api_response = api_instance.add_edge(graphId, edgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->addEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest]

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.addEdge(graphId, edgeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The primary key value of dst vertex.

        try {
            'String' result = apiInstance.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#deleteEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String srcLabel = new String(); // String | The label name of src vertex.
final oas_any_type_not_mapped srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex.
final String dstLabel = new String(); // String | The label name of dst vertex.
final oas_any_type_not_mapped dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of dst vertex.

try {
    final result = await api_instance.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The primary key value of dst vertex.

        try {
            'String' result = apiInstance.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#deleteEdge");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *srcLabel = person; // The label name of src vertex. (default to null)
oas_any_type_not_mapped *srcPrimaryKeyValue = 1; // The primary key value of src vertex. (default to null)
String *dstLabel = software; // The label name of dst vertex. (default to null)
oas_any_type_not_mapped *dstPrimaryKeyValue = 3; // The primary key value of dst vertex. (default to null)

// Remove edge from the graph
[apiInstance deleteEdgeWith:graphId
    srcLabel:srcLabel
    srcPrimaryKeyValue:srcPrimaryKeyValue
    dstLabel:dstLabel
    dstPrimaryKeyValue:dstPrimaryKeyValue
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var srcLabel = person; // {String} The label name of src vertex.
var srcPrimaryKeyValue = 1; // {oas_any_type_not_mapped} The primary key value of src vertex.
var dstLabel = software; // {String} The label name of dst vertex.
var dstPrimaryKeyValue = 3; // {oas_any_type_not_mapped} The primary key value of dst vertex.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var srcLabel = person;  // String | The label name of src vertex. (default to null)
            var srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
            var dstLabel = software;  // String | The label name of dst vertex. (default to null)
            var dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of dst vertex. (default to null)

            try {
                // Remove edge from the graph
                'String' result = apiInstance.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.deleteEdge: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$srcLabel = person; // String | The label name of src vertex.
$srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
$dstLabel = software; // String | The label name of dst vertex.
$dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The primary key value of dst vertex.

try {
    $result = $api_instance->deleteEdge($graphId, $srcLabel, $srcPrimaryKeyValue, $dstLabel, $dstPrimaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->deleteEdge: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $srcLabel = person; # String | The label name of src vertex.
my $srcPrimaryKeyValue = 1; # oas_any_type_not_mapped | The primary key value of src vertex.
my $dstLabel = software; # String | The label name of dst vertex.
my $dstPrimaryKeyValue = 3; # oas_any_type_not_mapped | The primary key value of dst vertex.

eval {
    my $result = $api_instance->deleteEdge(graphId => $graphId, srcLabel => $srcLabel, srcPrimaryKeyValue => $srcPrimaryKeyValue, dstLabel => $dstLabel, dstPrimaryKeyValue => $dstPrimaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->deleteEdge: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
srcLabel = person # String | The label name of src vertex. (default to null)
srcPrimaryKeyValue = 1 # oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
dstLabel = software # String | The label name of dst vertex. (default to null)
dstPrimaryKeyValue = 3 # oas_any_type_not_mapped | The primary key value of dst vertex. (default to null)

try:
    # Remove edge from the graph
    api_response = api_instance.delete_edge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->deleteEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let srcLabel = person; // String
    let srcPrimaryKeyValue = 1; // oas_any_type_not_mapped
    let dstLabel = software; // String
    let dstPrimaryKeyValue = 3; // oas_any_type_not_mapped

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.deleteEdge(graphId, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String edgeLabel = created; // String | The label name of querying edge.
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

        try {
            EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#getEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String edgeLabel = new String(); // String | The label name of querying edge.
final String srcLabel = new String(); // String | The label name of src vertex.
final oas_any_type_not_mapped srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex.
final String dstLabel = new String(); // String | The label name of dst vertex.
final oas_any_type_not_mapped dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of dst vertex's primary key

try {
    final result = await api_instance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String edgeLabel = created; // String | The label name of querying edge.
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

        try {
            EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#getEdge");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *edgeLabel = created; // The label name of querying edge. (default to null)
String *srcLabel = person; // The label name of src vertex. (default to null)
oas_any_type_not_mapped *srcPrimaryKeyValue = 1; // The primary key value of src vertex. (default to null)
String *dstLabel = software; // The label name of dst vertex. (default to null)
oas_any_type_not_mapped *dstPrimaryKeyValue = 3; // The value of dst vertex's primary key (default to null)

// Get the edge's properties with src and dst vertex primary keys.
[apiInstance getEdgeWith:graphId
    edgeLabel:edgeLabel
    srcLabel:srcLabel
    srcPrimaryKeyValue:srcPrimaryKeyValue
    dstLabel:dstLabel
    dstPrimaryKeyValue:dstPrimaryKeyValue
              completionHandler: ^(EdgeData output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var edgeLabel = created; // {String} The label name of querying edge.
var srcLabel = person; // {String} The label name of src vertex.
var srcPrimaryKeyValue = 1; // {oas_any_type_not_mapped} The primary key value of src vertex.
var dstLabel = software; // {String} The label name of dst vertex.
var dstPrimaryKeyValue = 3; // {oas_any_type_not_mapped} The value of dst vertex's primary key

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeLabel = created;  // String | The label name of querying edge. (default to null)
            var srcLabel = person;  // String | The label name of src vertex. (default to null)
            var srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
            var dstLabel = software;  // String | The label name of dst vertex. (default to null)
            var dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of dst vertex's primary key (default to null)

            try {
                // Get the edge's properties with src and dst vertex primary keys.
                EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.getEdge: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeLabel = created; // String | The label name of querying edge.
$srcLabel = person; // String | The label name of src vertex.
$srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
$dstLabel = software; // String | The label name of dst vertex.
$dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

try {
    $result = $api_instance->getEdge($graphId, $edgeLabel, $srcLabel, $srcPrimaryKeyValue, $dstLabel, $dstPrimaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->getEdge: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeLabel = created; # String | The label name of querying edge.
my $srcLabel = person; # String | The label name of src vertex.
my $srcPrimaryKeyValue = 1; # oas_any_type_not_mapped | The primary key value of src vertex.
my $dstLabel = software; # String | The label name of dst vertex.
my $dstPrimaryKeyValue = 3; # oas_any_type_not_mapped | The value of dst vertex's primary key

eval {
    my $result = $api_instance->getEdge(graphId => $graphId, edgeLabel => $edgeLabel, srcLabel => $srcLabel, srcPrimaryKeyValue => $srcPrimaryKeyValue, dstLabel => $dstLabel, dstPrimaryKeyValue => $dstPrimaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->getEdge: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeLabel = created # String | The label name of querying edge. (default to null)
srcLabel = person # String | The label name of src vertex. (default to null)
srcPrimaryKeyValue = 1 # oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
dstLabel = software # String | The label name of dst vertex. (default to null)
dstPrimaryKeyValue = 3 # oas_any_type_not_mapped | The value of dst vertex's primary key (default to null)

try:
    # Get the edge's properties with src and dst vertex primary keys.
    api_response = api_instance.get_edge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->getEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeLabel = created; // String
    let srcLabel = person; // String
    let srcPrimaryKeyValue = 1; // oas_any_type_not_mapped
    let dstLabel = software; // String
    let dstPrimaryKeyValue = 3; // oas_any_type_not_mapped

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        EdgeRequest edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]}; // EdgeRequest | 

        try {
            'String' result = apiInstance.updateEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#updateEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final EdgeRequest edgeRequest = new EdgeRequest(); // EdgeRequest | 

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

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        EdgeRequest edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]}; // EdgeRequest | 

        try {
            'String' result = apiInstance.updateEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#updateEdge");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
EdgeRequest *edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]}; //  (optional)

// Update edge's property
[apiInstance updateEdgeWith:graphId
    edgeRequest:edgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var opts = {
  'edgeRequest': {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]} // {EdgeRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeRequest = new EdgeRequest(); // EdgeRequest |  (optional) 

            try {
                // Update edge's property
                'String' result = apiInstance.updateEdge(graphId, edgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.updateEdge: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]}; // EdgeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeRequest = WWW::OPenAPIClient::Object::EdgeRequest->new(); # EdgeRequest | 

eval {
    my $result = $api_instance->updateEdge(graphId => $graphId, edgeRequest => $edgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->updateEdge: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]} # EdgeRequest |  (optional)

try:
    # Update edge's property
    api_response = api_instance.update_edge(graphId, edgeRequest=edgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->updateEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeRequest = {"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.3}]}; // EdgeRequest

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.updateEdge(graphId, edgeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#addVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final VertexEdgeRequest vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

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

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#addVertex");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
VertexEdgeRequest *vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // 

// Add vertex to the graph
[apiInstance addVertexWith:graphId
    vertexEdgeRequest:vertexEdgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // {VertexEdgeRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

            try {
                // Add vertex to the graph
                'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.addVertex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $vertexEdgeRequest = WWW::OPenAPIClient::Object::VertexEdgeRequest->new(); # VertexEdgeRequest | 

eval {
    my $result = $api_instance->addVertex(graphId => $graphId, vertexEdgeRequest => $vertexEdgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->addVertex: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]} # VertexEdgeRequest | 

try:
    # Add vertex to the graph
    api_response = api_instance.add_vertex(graphId, vertexEdgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->addVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_pk_name":"id","src_pk_value":1,"dst_pk_name":"id","dst_pk_value":3,"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.addVertex(graphId, vertexEdgeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The value of the querying vertex's primary key

        try {
            'String' result = apiInstance.deleteVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#deleteVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String label = new String(); // String | The label name of querying vertex.
final oas_any_type_not_mapped primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of the querying vertex's primary key

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

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The value of the querying vertex's primary key

        try {
            'String' result = apiInstance.deleteVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#deleteVertex");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *label = label_example; // The label name of querying vertex. (default to null)
oas_any_type_not_mapped *primaryKeyValue = ; // The value of the querying vertex's primary key (default to null)

// Remove vertex from the graph
[apiInstance deleteVertexWith:graphId
    label:label
    primaryKeyValue:primaryKeyValue
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var label = label_example; // {String} The label name of querying vertex.
var primaryKeyValue = ; // {oas_any_type_not_mapped} The value of the querying vertex's primary key

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var label = label_example;  // String | The label name of querying vertex. (default to null)
            var primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of the querying vertex's primary key (default to null)

            try {
                // Remove vertex from the graph
                'String' result = apiInstance.deleteVertex(graphId, label, primaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.deleteVertex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$label = label_example; // String | The label name of querying vertex.
$primaryKeyValue = ; // oas_any_type_not_mapped | The value of the querying vertex's primary key

try {
    $result = $api_instance->deleteVertex($graphId, $label, $primaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->deleteVertex: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $label = label_example; # String | The label name of querying vertex.
my $primaryKeyValue = ; # oas_any_type_not_mapped | The value of the querying vertex's primary key

eval {
    my $result = $api_instance->deleteVertex(graphId => $graphId, label => $label, primaryKeyValue => $primaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->deleteVertex: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
label = label_example # String | The label name of querying vertex. (default to null)
primaryKeyValue =  # oas_any_type_not_mapped | The value of the querying vertex's primary key (default to null)

try:
    # Remove vertex from the graph
    api_response = api_instance.delete_vertex(graphId, label, primaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->deleteVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let label = label_example; // String
    let primaryKeyValue = ; // oas_any_type_not_mapped

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.deleteVertex(graphId, label, primaryKeyValue, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | The id of the graph
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

        try {
            VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#getVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of the graph
final String label = new String(); // String | The label name of querying vertex.
final oas_any_type_not_mapped primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of querying vertex.

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

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | The id of the graph
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

        try {
            VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#getVertex");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; // The id of the graph (default to null)
String *label = label_example; // The label name of querying vertex. (default to null)
oas_any_type_not_mapped *primaryKeyValue = ; // The primary key value of querying vertex. (default to null)

// Get the vertex's properties with vertex primary key.
[apiInstance getVertexWith:graphId
    label:label
    primaryKeyValue:primaryKeyValue
              completionHandler: ^(VertexData output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} The id of the graph
var label = label_example; // {String} The label name of querying vertex.
var primaryKeyValue = ; // {oas_any_type_not_mapped} The primary key value of querying vertex.

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String | The id of the graph (default to null)
            var label = label_example;  // String | The label name of querying vertex. (default to null)
            var primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of querying vertex. (default to null)

            try {
                // Get the vertex's properties with vertex primary key.
                VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.getVertex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | The id of the graph
$label = label_example; // String | The label name of querying vertex.
$primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

try {
    $result = $api_instance->getVertex($graphId, $label, $primaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->getVertex: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | The id of the graph
my $label = label_example; # String | The label name of querying vertex.
my $primaryKeyValue = ; # oas_any_type_not_mapped | The primary key value of querying vertex.

eval {
    my $result = $api_instance->getVertex(graphId => $graphId, label => $label, primaryKeyValue => $primaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->getVertex: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String | The id of the graph (default to null)
label = label_example # String | The label name of querying vertex. (default to null)
primaryKeyValue =  # oas_any_type_not_mapped | The primary key value of querying vertex. (default to null)

try:
    # Get the vertex's properties with vertex primary key.
    api_response = api_instance.get_vertex(graphId, label, primaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->getVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let label = label_example; // String
    let primaryKeyValue = ; // oas_any_type_not_mapped

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.getVertex(graphId, label, primaryKeyValue, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexRequest vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#updateVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final VertexRequest vertexRequest = new VertexRequest(); // VertexRequest | 

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

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexRequest vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#updateVertex");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
VertexRequest *vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; //  (optional)

// Update vertex's property
[apiInstance updateVertexWith:graphId
    vertexRequest:vertexRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var opts = {
  'vertexRequest': {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}} // {VertexRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var vertexRequest = new VertexRequest(); // VertexRequest |  (optional) 

            try {
                // Update vertex's property
                'String' result = apiInstance.updateVertex(graphId, vertexRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.updateVertex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $vertexRequest = WWW::OPenAPIClient::Object::VertexRequest->new(); # VertexRequest | 

eval {
    my $result = $api_instance->updateVertex(graphId => $graphId, vertexRequest => $vertexRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->updateVertex: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}} # VertexRequest |  (optional)

try:
    # Update vertex's property
    api_response = api_instance.update_vertex(graphId, vertexRequest=vertexRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->updateVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let vertexRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexRequest

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.updateVertex(graphId, vertexRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProc");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final byte[] body = new byte[](); // byte[] | 

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

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProc");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// run queries on graph
[apiInstance callProcWith:graphId
    body:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var graphId = graphId_example; // {String} 
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // run queries on graph
                byte[] result = apiInstance.callProc(graphId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.callProc: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$graphId = graphId_example; // String | 
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $graphId = graphId_example; # String | 
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

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

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

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
graphId = graphId_example # String |  (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # run queries on graph
    api_response = api_instance.call_proc(graphId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->callProc: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.callProc(graphId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProcCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProcCurrent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final byte[] body = new byte[](); // byte[] | 

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

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProcCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProcCurrent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// run queries on the running graph
[apiInstance callProcCurrentWith:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // run queries on the running graph
                byte[] result = apiInstance.callProcCurrent(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.callProcCurrent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

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

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

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # run queries on the running graph
    api_response = api_instance.call_proc_current(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->callProcCurrent: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.callProcCurrent(body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhoc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhoc");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final byte[] body = new byte[](); // byte[] | 

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

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhoc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhoc");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// Submit adhoc query to the Interactive Query Service.
[apiInstance runAdhocWith:graphId
    body:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var graphId = graphId_example; // {String} 
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // Submit adhoc query to the Interactive Query Service.
                byte[] result = apiInstance.runAdhoc(graphId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.runAdhoc: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$graphId = graphId_example; // String | 
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $graphId = graphId_example; # String | 
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

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

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

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
graphId = graphId_example # String |  (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # Submit adhoc query to the Interactive Query Service.
    api_response = api_instance.run_adhoc(graphId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->runAdhoc: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.runAdhoc(graphId, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhocCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhocCurrent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final byte[] body = new byte[](); // byte[] | 

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

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhocCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhocCurrent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// Submit adhoc query to the Interactive Query Service.
[apiInstance runAdhocCurrentWith:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // Submit adhoc query to the Interactive Query Service.
                byte[] result = apiInstance.runAdhocCurrent(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.runAdhocCurrent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

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

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

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # Submit adhoc query to the Interactive Query Service.
    api_response = api_instance.run_adhoc_current(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->runAdhocCurrent: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.runAdhocCurrent(body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UtilsApi apiInstance = new UtilsApi();
        File filestorage = BINARY_DATA_HERE; // File | 

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final File filestorage = new File(); // File | 

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

import org.openapitools.client.api.UtilsApi;

public class UtilsApiExample {
    public static void main(String[] args) {
        UtilsApi apiInstance = new UtilsApi();
        File filestorage = BINARY_DATA_HERE; // File | 

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}

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

[apiInstance uploadFileWith:filestorage
              completionHandler: ^(UploadFileResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.UtilsApi()
var opts = {
  'filestorage': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UtilsApi();
            var filestorage = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                UploadFileResponse result = apiInstance.uploadFile(filestorage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UtilsApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UtilsApi();
$filestorage = BINARY_DATA_HERE; // File | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.UtilsApi()
filestorage = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.upload_file(filestorage=filestorage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilsApi->uploadFile: %s\n" % e)

extern crate UtilsApi;

pub fn main() {
    let filestorage = BINARY_DATA_HERE; // File

    let mut context = UtilsApi::Context::default();
    let result = client.uploadFile(filestorage, &context).wait();

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