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();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.createEdgeType(graphId, createEdgeType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createEdgeType: $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 | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

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

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

[apiInstance createEdgeTypeWith:graphId
    createEdgeType:createEdgeType
              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} 
var opts = {
  'createEdgeType':  // {CreateEdgeType} 
};

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

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

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

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

            try {
                'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createEdgeType: " + 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 | 
$createEdgeType = ; // CreateEdgeType | 

try {
    $result = $api_instance->createEdgeType($graphId, $createEdgeType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createEdgeType: ', $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 | 
my $createEdgeType = WWW::OPenAPIClient::Object::CreateEdgeType->new(); # CreateEdgeType | 

eval {
    my $result = $api_instance->createEdgeType(graphId => $graphId, createEdgeType => $createEdgeType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createEdgeType: $@\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 |  (default to null)
createEdgeType =  # CreateEdgeType |  (optional)

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createEdgeType(graphId, createEdgeType, &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 | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.createVertexType(graphId, createVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createVertexType: $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 | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

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

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

[apiInstance createVertexTypeWith:graphId
    createVertexType:createVertexType
              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} 
var createVertexType = ; // {CreateVertexType} 

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

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

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

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

            try {
                'String' result = apiInstance.createVertexType(graphId, createVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createVertexType: " + 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 | 
$createVertexType = ; // CreateVertexType | 

try {
    $result = $api_instance->createVertexType($graphId, $createVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createVertexType: ', $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 | 
my $createVertexType = WWW::OPenAPIClient::Object::CreateVertexType->new(); # CreateVertexType | 

eval {
    my $result = $api_instance->createVertexType(graphId => $graphId, createVertexType => $createVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createVertexType: $@\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 |  (default to null)
createVertexType =  # CreateVertexType | 

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createVertexType(graphId, createVertexType, &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 | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 
final String sourceVertexType = new String(); // String | 
final String destinationVertexType = new String(); // String | 

try {
    final result = await api_instance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEdgeType: $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 | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

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

// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)
String *sourceVertexType = sourceVertexType_example; //  (default to null)
String *destinationVertexType = destinationVertexType_example; //  (default to null)

[apiInstance deleteEdgeTypeWith:graphId
    typeName:typeName
    sourceVertexType:sourceVertexType
    destinationVertexType:destinationVertexType
              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} 
var typeName = typeName_example; // {String} 
var sourceVertexType = sourceVertexType_example; // {String} 
var destinationVertexType = destinationVertexType_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)
            var sourceVertexType = sourceVertexType_example;  // String |  (default to null)
            var destinationVertexType = destinationVertexType_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteEdgeType: " + 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 | 
$typeName = typeName_example; // String | 
$sourceVertexType = sourceVertexType_example; // String | 
$destinationVertexType = destinationVertexType_example; // String | 

try {
    $result = $api_instance->deleteEdgeType($graphId, $typeName, $sourceVertexType, $destinationVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: ', $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 | 
my $typeName = typeName_example; # String | 
my $sourceVertexType = sourceVertexType_example; # String | 
my $destinationVertexType = destinationVertexType_example; # String | 

eval {
    my $result = $api_instance->deleteEdgeType(graphId => $graphId, typeName => $typeName, sourceVertexType => $sourceVertexType, destinationVertexType => $destinationVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: $@\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 |  (default to null)
typeName = typeName_example # String |  (default to null)
sourceVertexType = sourceVertexType_example # String |  (default to null)
destinationVertexType = destinationVertexType_example # String |  (default to null)

try:
    api_response = api_instance.delete_edge_type(graphId, typeName, sourceVertexType, destinationVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String
    let sourceVertexType = sourceVertexType_example; // String
    let destinationVertexType = destinationVertexType_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType, &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 | 
        String typeName = typeName_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.deleteVertexType(graphId, typeName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteVertexType: $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 | 
        String typeName = typeName_example; // String | 

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

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

[apiInstance deleteVertexTypeWith:graphId
    typeName:typeName
              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} 
var typeName = typeName_example; // {String} 

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

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

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

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

            try {
                'String' result = apiInstance.deleteVertexType(graphId, typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteVertexType: " + 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 | 
$typeName = typeName_example; // String | 

try {
    $result = $api_instance->deleteVertexType($graphId, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->deleteVertexType: ', $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 | 
my $typeName = typeName_example; # String | 

eval {
    my $result = $api_instance->deleteVertexType(graphId => $graphId, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->deleteVertexType: $@\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 |  (default to null)
typeName = typeName_example # String |  (default to null)

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteVertexType(graphId, typeName, &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 get schema

        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 get schema

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 get schema

        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 get schema (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 get schema

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 get schema (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 get schema

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 get schema

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 get schema (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();
        String graphId = graphId_example; // String | 
        Integer snapshotId = 56; // Integer | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.getSnapshotStatus(graphId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshotStatus: $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 | 
        Integer snapshotId = 56; // Integer | 

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

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

[apiInstance getSnapshotStatusWith:graphId
    snapshotId:snapshotId
              completionHandler: ^(SnapshotStatus 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} 
var snapshotId = 56; // {Integer} 

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

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

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

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

            try {
                SnapshotStatus result = apiInstance.getSnapshotStatus(graphId, snapshotId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getSnapshotStatus: " + 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 | 
$snapshotId = 56; // Integer | 

try {
    $result = $api_instance->getSnapshotStatus($graphId, $snapshotId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->getSnapshotStatus: ', $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 | 
my $snapshotId = 56; # Integer | 

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

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getSnapshotStatus(graphId, snapshotId, &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.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 | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.updateEdgeType(graphId, createEdgeType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateEdgeType: $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 | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

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

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

[apiInstance updateEdgeTypeWith:graphId
    createEdgeType:createEdgeType
              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} 
var createEdgeType = ; // {CreateEdgeType} 

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

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

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

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

            try {
                'String' result = apiInstance.updateEdgeType(graphId, createEdgeType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.updateEdgeType: " + 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 | 
$createEdgeType = ; // CreateEdgeType | 

try {
    $result = $api_instance->updateEdgeType($graphId, $createEdgeType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->updateEdgeType: ', $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 | 
my $createEdgeType = WWW::OPenAPIClient::Object::CreateEdgeType->new(); # CreateEdgeType | 

eval {
    my $result = $api_instance->updateEdgeType(graphId => $graphId, createEdgeType => $createEdgeType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->updateEdgeType: $@\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 |  (default to null)
createEdgeType =  # CreateEdgeType | 

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.updateEdgeType(graphId, createEdgeType, &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 | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.updateVertexType(graphId, createVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateVertexType: $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 | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

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

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

[apiInstance updateVertexTypeWith:graphId
    createVertexType:createVertexType
              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} 
var createVertexType = ; // {CreateVertexType} 

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

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

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

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

            try {
                'String' result = apiInstance.updateVertexType(graphId, createVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.updateVertexType: " + 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 | 
$createVertexType = ; // CreateVertexType | 

try {
    $result = $api_instance->updateVertexType($graphId, $createVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->updateVertexType: ', $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 | 
my $createVertexType = WWW::OPenAPIClient::Object::CreateVertexType->new(); # CreateVertexType | 

eval {
    my $result = $api_instance->updateVertexType(graphId => $graphId, createVertexType => $createVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->updateVertexType: $@\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 |  (default to null)
createVertexType =  # CreateVertexType | 

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

extern crate AdminServiceGraphManagementApi;

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

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.updateVertexType(graphId, createVertexType, &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();
        StopServiceRequest stopServiceRequest = ; // StopServiceRequest | 

        try {
            'String' result = apiInstance.stopService(stopServiceRequest);
            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();

final StopServiceRequest stopServiceRequest = new StopServiceRequest(); // StopServiceRequest | 

try {
    final result = await api_instance.stopService(stopServiceRequest);
    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();
        StopServiceRequest stopServiceRequest = ; // StopServiceRequest | 

        try {
            'String' result = apiInstance.stopService(stopServiceRequest);
            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];
StopServiceRequest *stopServiceRequest = ; //  (optional)

[apiInstance stopServiceWith:stopServiceRequest
              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 = {
  'stopServiceRequest':  // {StopServiceRequest} 
};

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

            try {
                'String' result = apiInstance.stopService(stopServiceRequest);
                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();
$stopServiceRequest = ; // StopServiceRequest | 

try {
    $result = $api_instance->stopService($stopServiceRequest);
    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();
my $stopServiceRequest = WWW::OPenAPIClient::Object::StopServiceRequest->new(); # StopServiceRequest | 

eval {
    my $result = $api_instance->stopService(stopServiceRequest => $stopServiceRequest);
    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()
stopServiceRequest =  # StopServiceRequest |  (optional)

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

extern crate AdminServiceServiceManagementApi;

pub fn main() {
    let stopServiceRequest = ; // StopServiceRequest

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.stopService(stopServiceRequest, &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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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 | 
        array[DeleteEdgeRequest] deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

        try {
            'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
            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 array[DeleteEdgeRequest] deleteEdgeRequest = new array[DeleteEdgeRequest](); // array[DeleteEdgeRequest] | 

try {
    final result = await api_instance.deleteEdge(graphId, deleteEdgeRequest);
    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 | 
        array[DeleteEdgeRequest] deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

        try {
            'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
            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)
array[DeleteEdgeRequest] *deleteEdgeRequest = ; // 

// Remove edge from the graph
[apiInstance deleteEdgeWith:graphId
    deleteEdgeRequest:deleteEdgeRequest
              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 deleteEdgeRequest = ; // {array[DeleteEdgeRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEdge(graphId, deleteEdgeRequest, 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 deleteEdgeRequest = new array[DeleteEdgeRequest](); // array[DeleteEdgeRequest] | 

            try {
                // Remove edge from the graph
                'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
                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 | 
$deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

try {
    $result = $api_instance->deleteEdge($graphId, $deleteEdgeRequest);
    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 $deleteEdgeRequest = [WWW::OPenAPIClient::Object::array[DeleteEdgeRequest]->new()]; # array[DeleteEdgeRequest] | 

eval {
    my $result = $api_instance->deleteEdge(graphId => $graphId, deleteEdgeRequest => $deleteEdgeRequest);
    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)
deleteEdgeRequest =  # array[DeleteEdgeRequest] | 

try:
    # Remove edge from the graph
    api_response = api_instance.delete_edge(graphId, deleteEdgeRequest)
    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 deleteEdgeRequest = ; // array[DeleteEdgeRequest]

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.deleteEdge(graphId, deleteEdgeRequest, &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 | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[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 array[EdgeRequest] edgeRequest = new array[EdgeRequest](); // array[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 | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[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)
array[EdgeRequest] *edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // 

// 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 edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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.updateEdge(graphId, edgeRequest, 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 array[EdgeRequest](); // array[EdgeRequest] | 

            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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[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::array[EdgeRequest]->new()]; # array[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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}] # array[EdgeRequest] | 

try:
    # Update edge's property
    api_response = api_instance.update_edge(graphId, 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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // 

// Add vertex (and edge) 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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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 (and edge) 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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]} # VertexEdgeRequest | 

try:
    # Add vertex (and edge) 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_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","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 | 
        array[DeleteVertexRequest] deleteVertexRequest = ; // array[DeleteVertexRequest] | 

        try {
            'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
            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 array[DeleteVertexRequest] deleteVertexRequest = new array[DeleteVertexRequest](); // array[DeleteVertexRequest] | 

try {
    final result = await api_instance.deleteVertex(graphId, deleteVertexRequest);
    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 | 
        array[DeleteVertexRequest] deleteVertexRequest = ; // array[DeleteVertexRequest] | 

        try {
            'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
            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)
array[DeleteVertexRequest] *deleteVertexRequest = ; // 

// Remove vertex from the graph
[apiInstance deleteVertexWith:graphId
    deleteVertexRequest:deleteVertexRequest
              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 deleteVertexRequest = ; // {array[DeleteVertexRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteVertex(graphId, deleteVertexRequest, 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 deleteVertexRequest = new array[DeleteVertexRequest](); // array[DeleteVertexRequest] | 

            try {
                // Remove vertex from the graph
                'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
                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 | 
$deleteVertexRequest = ; // array[DeleteVertexRequest] | 

try {
    $result = $api_instance->deleteVertex($graphId, $deleteVertexRequest);
    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 $deleteVertexRequest = [WWW::OPenAPIClient::Object::array[DeleteVertexRequest]->new()]; # array[DeleteVertexRequest] | 

eval {
    my $result = $api_instance->deleteVertex(graphId => $graphId, deleteVertexRequest => $deleteVertexRequest);
    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)
deleteVertexRequest =  # array[DeleteVertexRequest] | 

try:
    # Remove vertex from the graph
    api_response = api_instance.delete_vertex(graphId, deleteVertexRequest)
    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 deleteVertexRequest = ; // array[DeleteVertexRequest]

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.deleteVertex(graphId, deleteVertexRequest, &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 | 
        VertexEdgeRequest vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
            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 VertexEdgeRequest vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

try {
    final result = await api_instance.updateVertex(graphId, vertexEdgeRequest);
    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 | 
        VertexEdgeRequest vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
            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)
VertexEdgeRequest *vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // 

// Update vertex's property
[apiInstance updateVertexWith: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 = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // {VertexEdgeRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateVertex(graphId, vertexEdgeRequest, 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 vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

            try {
                // Update vertex's property
                'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
                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 | 
$vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

try {
    $result = $api_instance->updateVertex($graphId, $vertexEdgeRequest);
    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 $vertexEdgeRequest = WWW::OPenAPIClient::Object::VertexEdgeRequest->new(); # VertexEdgeRequest | 

eval {
    my $result = $api_instance->updateVertex(graphId => $graphId, vertexEdgeRequest => $vertexEdgeRequest);
    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)
vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}} # VertexEdgeRequest | 

try:
    # Update vertex's property
    api_response = api_instance.update_vertex(graphId, vertexEdgeRequest)
    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 vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.updateVertex(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.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);
}